[Java][НП] - Пицерија

Треба да се развие систем за електронска нарачка од пицерија. Менито на пицеријата се состои од следново:

    Pizza:
        Standard: 10$
        Pepperoni: 12$
        Vegetarian: 8$

    Extra
        Ketchup 3$
        Coke 5$

За да го претставите менито, секоја ставка треба да имплементира interface Item која опишува една ставка од менито и ги дефинира следниве методи:

    getPrice():int - ја дава цената за конкретната ставка

Следно, дефинирајте две класи ExtraItem и PizzaItem за да може да правите разлика меѓу пици и останатите работи во нарачката. И двете класи треба да имаат еден конструктор кој прима еден String аргумент.

    ExtraItem(String type) - валидни вредности за type се { "Coke", "Ketchup" }
    PizzaItem(String type) - валидни вредности за type се { Standard , Pepperoni , Vegetarian }

Ако за type се проследи некоја невалидна вредност (која ја нема на менито) треба да се фрли исклучок InvalidExtraTypeException, односно InvalidPizzaTypeException.

Последно имплементирајте ја класата Order. Таа треба да ги нуди следните функционалности:

    Order() - креира нова празна нарачка

    addItem(Item item, int count) - соодветната ставка се додава во нарачката (count означува колку примероци сакаме од дадената ставка). Aко count е поголем од 10 се фрла исклучок ItemOutOfStockException(item). Доколку во нарачката веќе ја има соодветната ставка Item тогаш истата се заменува со нова. Следниот код резултира со нарачка со една стандардна пица:

    Order order = new Order(); order.addItem(new PizzaItem("Standard"), 2); order.addItem(new PizzaItem("Standard"), 1);

    getPrice():int - ја враќа вкупната цена на нарачката
    displayOrder() - ја печати содржината на нарачката со соодветни редни броеви пред секоја ставка, името, количината и збирна сума на ставката, како и вкупна сума за целата нарачка. За редниот број се резервирани 3 места порамнети во десно, за имињата на ставките се резервирани 15 места со порамнување од лево, за кардиналноста две места порамнети во десно и за цената на една ставка 5 места порамнети во десно. За "Total:" се резервирани 22 места со порамнување од лево и за вкупната цена 5 места порамнети во десно. Пример:

      1.Standard       x 2   20$
      2.Vegetarian     x 1    8$
      3.Coke           x 3   15$
    Total:                   43$

Редоследот по кој се печатат ставките е оној по кој тие се внесувани во нарачката. Доколку некоја ставка се внесе повторно нејзиното место не се менува.

    removeItem(int idx) - се отстранува нарачката со даден индекс (сите нарачки со поголеми индекси се поместуваат во лево). Доколку не постои нарачка со таков индекс треба да се фрли исклучок ArrayIndexOutOfBоundsException(idx)
    lock() - ја заклучува нарачката. За да може нарачката да се заклучи треба истата да има барем една ставка, во спротивно фрлете исклучок EmptyOrderException.

Откако ќе се заклучи нарачката треба веќе да не може да се менува со методите removeItem, addItem. Повикот на овие методи резултира со исклучок од типот OrderLockedException.



import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.IntStream;

class EmptyOrder extends Exception {
    public EmptyOrder() {
        super("Empty Order");
    }
}

class ArrayIndexOutOfBоundsException extends Exception {
    public ArrayIndexOutOfBоundsException(int idx) {
        super("ArrayIndexOutOfBоundsException");
    }
}

class OrderLockedException extends Exception {
    public OrderLockedException() {
        super("OrderLockedException");
    }
}

class InvalidExtraTypeException extends Exception {
    public InvalidExtraTypeException() {
        super("InvalidExtraTypeException");
    }
}

class InvalidPizzaTypeException extends Exception {
    public InvalidPizzaTypeException() {
        super("InvalidPizzaTypeException");
    }
}

class ItemOutOfStockException extends Exception {
    public ItemOutOfStockException(Item item) {
        super("ItemOutOfStockException");
    }
}
interface Item {
    public int getPrice();

    public String getType();
}

class PizzaItem implements Item {
    private String pizza_type;
    private int price;
    private final int[] PIZZA_PRICES = {10, 12, 8};
    private final List<String> PIZZA_TYPES =
            Arrays.asList("Standard", "Pepperoni", "Vegetarian");

    public PizzaItem(String type) throws InvalidPizzaTypeException {
        if (!PIZZA_TYPES.contains(type))
            throw new InvalidPizzaTypeException();
        this.pizza_type = type;
        this.price = PIZZA_PRICES[PIZZA_TYPES.indexOf(type)];
    }

    public String getType() {
        return pizza_type;
    }

    @Override
    public int getPrice() {
        return price;
    }
}


class ExtraItem implements Item {
    private String extra_type;
    private int price;
    private final int[] EXTRA_PRICES = {3, 5};
    private final List<String> EXTRA_TYPES =
            Arrays.asList("Ketchup", "Coke");

    public ExtraItem(String type) throws InvalidExtraTypeException {
        if (!EXTRA_TYPES.contains(type))
            throw new InvalidExtraTypeException();
        this.extra_type = type;
        this.price = EXTRA_PRICES[EXTRA_TYPES.indexOf(type)];
    }

    public String getType() {
        return extra_type;
    }

    @Override
    public int getPrice() {
        return price;
    }
}

class Order {
    private Item[] orderList;
    private int[] countForItem;
    private boolean lock;

    public Order() {
        orderList = new Item[0];
        countForItem = new int[0];
        lock = false;
    }

    public void addItem(Item item, int count) throws OrderLockedException, ItemOutOfStockException {
        if(lock)
            throw new OrderLockedException();
        if (count > 10)
            throw new ItemOutOfStockException(item);
        for (int i = 0; i < orderList.length; i++) {
            if (orderList[i].getType().equals(item.getType())) {
                orderList[i] = item;
                countForItem[i] = count;
                return;
            }
        }
        Item[] copy = Arrays.copyOf(orderList, orderList.length + 1);
        int[] copy2 = Arrays.copyOf(countForItem, countForItem.length + 1);
        copy[copy.length - 1] = item;
        copy2[copy2.length - 1] = count;
        orderList = copy;
        countForItem = copy2;
    }


    public int getPrice() {
        return IntStream.range(0, orderList.length).map(i -> orderList[i].getPrice() * countForItem[i]).sum();
    }

    public void displayOrder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < orderList.length; i++) {
            sb.append(String.format("%3d.%-15sx%2d%5d$\n",
                    (i + 1), orderList[i].getType(), countForItem[i], getPriceForCurrentItem(orderList[i], countForItem[i])));
        }
        sb.append(String.format("%-22s%5d$","Total:",getPrice()));
        System.out.println(sb.toString());
    }

    private int getPriceForCurrentItem(Item item, int i) {
        return item.getPrice() * i;
    }

    public void removeItem(int idx) throws OrderLockedException {
        if(lock)
            throw new OrderLockedException();
        if (idx > orderList.length - 1)
            throw new ArrayIndexOutOfBoundsException(idx);

        Item[] copy = Arrays.copyOf(orderList, orderList.length-1);
        int [] copy2 = Arrays.copyOf(countForItem,countForItem.length-1);
        for (int i = 0; i < orderList.length; i++) {
            if(i==idx)
                break;
            copy[i] = orderList[i];
            copy2[i] = countForItem[i];
        }
        for (int i=idx+1; i < orderList.length; i++) {
            copy[i-1] = orderList[i];
            copy2[i-1] = countForItem[i];
        }
        orderList = copy;
        countForItem = copy2;

    }
    public void lock() throws EmptyOrder {
        if(orderList.length==0)
            throw new EmptyOrder();
        this.lock = true;
    }
}

public class PizzaOrderTest {

    public static void main(String[] args) {
        Scanner jin = new Scanner(System.in);
        int k = jin.nextInt();
        if (k == 0) { //test Item
            try {
                String type = jin.next();
                String name = jin.next();
                Item item = null;
                if (type.equals("Pizza")) item = new PizzaItem(name);
                else item = new ExtraItem(name);
                System.out.println(item.getPrice());
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
        }
        if (k == 1) { // test simple order
            Order order = new Order();
            while (true) {
                try {
                    String type = jin.next();
                    String name = jin.next();
                    Item item = null;
                    if (type.equals("Pizza")) item = new PizzaItem(name);
                    else item = new ExtraItem(name);
                    if (!jin.hasNextInt()) break;
                    order.addItem(item, jin.nextInt());
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            jin.next();
            System.out.println(order.getPrice());
            order.displayOrder();
            while (true) {
                try {
                    String type = jin.next();
                    String name = jin.next();
                    Item item = null;
                    if (type.equals("Pizza")) item = new PizzaItem(name);
                    else item = new ExtraItem(name);
                    if (!jin.hasNextInt()) break;
                    order.addItem(item, jin.nextInt());
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            System.out.println(order.getPrice());
            order.displayOrder();
        }
        if (k == 2) { // test order with removing
            Order order = new Order();
            while (true) {
                try {
                    String type = jin.next();
                    String name = jin.next();
                    Item item = null;
                    if (type.equals("Pizza")) item = new PizzaItem(name);
                    else item = new ExtraItem(name);
                    if (!jin.hasNextInt()) break;
                    order.addItem(item, jin.nextInt());
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            jin.next();
            System.out.println(order.getPrice());
            order.displayOrder();
            while (jin.hasNextInt()) {
                try {
                    int idx = jin.nextInt();
                    order.removeItem(idx);
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            System.out.println(order.getPrice());
            order.displayOrder();
        }
        if (k == 3) { //test locking & exceptions
            Order order = new Order();
            try {
                order.lock();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                order.addItem(new ExtraItem("Coke"), 1);
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                order.lock();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                order.removeItem(0);
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
        }
    }

}




Sample input

0 Extra Ketchup

Sample output

3