Java 作业 Gourmet Coffee System 作业2

Catalog Class

package ProductOrder;
import java.io.*;
import java.util.*;

public class Catalog implements Iterable<Product>{
	private ArrayList<Product> products;
	public Catalog() {
		this.products = new ArrayList<>();
	}
	public void addProduct(Product product) {
		this.products.add(product);
	}
	public Iterator<Product> iterator() {
        return products.iterator();
    }
	public Product getProduct(String code){
        for(Product product:this.products){
            if(product.getCode().equals(code)){
                return product;
            }
        }
        return null;
	}
	public int getNumberOfProducts(){
        return this.products.size();
    }
}

Oeder Class

package ProductOrder;
import java.io.*;
import java.util.*;
public class Order implements Iterable<OrderItem>{
	private ArrayList<OrderItem>items;
	public Order() {
		this.items = new ArrayList<>();
	}
	public Iterator<OrderItem> iterator() {
		return items.iterator();
	}
	public void addItem(OrderItem orderItem) {
		this.items.add(orderItem);
	}
	public void removeItem(OrderItem orderItem) {
		this.items.remove(orderItem);
	}
	public OrderItem getItem(Product product) {
		for(OrderItem orderitem:this.items ) {
			if(orderitem.getProduct().equals(product))
				return orderitem;
		}
		return null;
	}
	public int getNumberOfItems() {
		return this.items.size();
	}
	public double getTotalCost() {
		double totalCost = 0;
		for(OrderItem orderitem:this.items) {
			totalCost+=orderitem.getValue();
		}
		return totalCost;
	}
}

Sales Class

package ProductOrder;
import java.io.*;
import java.util.*;
public class Sales implements Iterable<Order>{
	private ArrayList<Order>orders;
	public Sales() {
		this.orders = new ArrayList<>();
	}
	public void addOrder(Order order) {
		this.orders.add(order);
	}
	public Iterator<Order> iterator() {
		return orders.iterator();
	}
	public int getNumberOfOrders() {
		return this.orders.size();
	}
}

GourmetCoffee Class

import java.io.*;
import java.util.*;
import java.text.*;

public class GourmetCoffee  {

	private static BufferedReader  stdIn =
		new  BufferedReader(new  InputStreamReader(System.in));
	private static PrintWriter  stdOut =
		new  PrintWriter(System.out, true);
	private static PrintWriter  stdErr =
		new  PrintWriter(System.err, true);

	private static final NumberFormat CURRENCY =
		NumberFormat.getCurrencyInstance();

	private Catalog  catalog;
	private Order  currentOrder;
	private Sales  sales;
	public static void  main(String[]  args) throws IOException  {

		GourmetCoffee  application = new  GourmetCoffee();
		application.run();

	}
	private GourmetCoffee() {

		this.catalog = loadCatalog();
		this.sales = loadSales(this.catalog);
		this.currentOrder = new Order();
	}
	private Catalog loadCatalog() {

		Catalog catalog = new Catalog();

		catalog.addProduct(new Coffee(
			"C001", "Colombia, Whole, 1 lb", 17.99,
			"Colombia", "Medium", "Rich and Hearty", "Rich", "Medium", "Full"));
		catalog.addProduct(new Coffee(
			"C002", "Colombia, Ground, 1 lb", 18.75,
			"Colombia", "Medium", "Rich and Hearty", "Rich", "Medium","Full"));
		catalog.addProduct(new Coffee(
			"C003", "Italian Roasts, Whole, 1 lb", 16.80,
			"Latin American Blend", "Italian Roast", "Dark and heavy",
			"Intense", "Low", "Medium"));
		catalog.addProduct(new Coffee(
			"C004", "Italian Roasts, Ground, 1 lb", 17.55,
			"Latin American Blend", "Italian Roast", "Dark and heavy",
			"Intense", "Low", "Medium"));
		catalog.addProduct(new Coffee(
			"C005", "French Roasts, Whole, 1 lb", 16.80,
			"Latin American Blend", "French Roast", "Bittersweet, full intense",
			"Intense, full", "None", "Medium"));
		catalog.addProduct(new CoffeeBrewer(
			"B001", "Home Coffee Brewer", 150.00,
			"Brewer 100", "Pourover", 6));
		catalog.addProduct(new CoffeeBrewer(
			"B002", "Coffee Brewer, 2 Warmers", 200.00,
			"Brewer 200", "Pourover", 12));
		catalog.addProduct(new CoffeeBrewer(
			"B003", "Coffee Brewer, 3 Warmers", 280.00,
			"Brewer 210", "Pourover", 12));

		catalog.addProduct(
			new Product("A001", "Almond Flavored Syrup", 9.00));
		catalog.addProduct(
			new Product("A002", "Irish Creme Flavored Syrup", 9.00));
		catalog.addProduct(
			new Product("A003", "Mint Flavored syrup", 9.00));
		catalog.addProduct(
			new Product("A004", "Caramel Flavored Syrup", 9.00));
		catalog.addProduct(
			new Product("A005", "Gourmet Coffee Cookies", 12.00));

		return catalog;
	}
	private Sales loadSales(Catalog catalog) {

		Sales sales = new Sales();
		Order[] orders = new Order[6];

		orders[0] = new Order();
		orders[0].addItem(new OrderItem(catalog.getProduct("C001"), 5));
		sales.addOrder(orders[0]);

		orders[1] = new Order();
		orders[1].addItem(new OrderItem(catalog.getProduct("C002"), 2));
		orders[1].addItem(new OrderItem(catalog.getProduct("A001"), 2));
		orders[1].addItem(new OrderItem(catalog.getProduct("A003"), 2));
		sales.addOrder(orders[1]);

		orders[2] = new Order();
		orders[2].addItem(new OrderItem(catalog.getProduct("B002"), 1));
		orders[2].addItem(new OrderItem(catalog.getProduct("A003"), 3));
		sales.addOrder(orders[2]);

		orders[3] = new Order();
		orders[3].addItem(new OrderItem(catalog.getProduct("B003"), 2));
		orders[3].addItem(new OrderItem(catalog.getProduct("C001"), 3));
		orders[3].addItem(new OrderItem(catalog.getProduct("C003"), 3));
		orders[3].addItem(new OrderItem(catalog.getProduct("C005"), 3));
		orders[3].addItem(new OrderItem(catalog.getProduct("A001"), 3));
		orders[3].addItem(new OrderItem(catalog.getProduct("A004"), 2));
		sales.addOrder(orders[3]);
		
		orders[4] = new Order();
		orders[4].addItem(new OrderItem(catalog.getProduct("B001"), 1));
		orders[4].addItem(new OrderItem(catalog.getProduct("C002"), 2));
		orders[4].addItem(new OrderItem(catalog.getProduct("C003"), 2));
		orders[4].addItem(new OrderItem(catalog.getProduct("A001"), 2));
		orders[4].addItem(new OrderItem(catalog.getProduct("A002"), 6));
		sales.addOrder(orders[4]);
		
		orders[5] = new Order();
		orders[5].addItem(new OrderItem(catalog.getProduct("B001"), 1));
		orders[5].addItem(new OrderItem(catalog.getProduct("C001"), 1));
		orders[5].addItem(new OrderItem(catalog.getProduct("C005"), 5));
		orders[5].addItem(new OrderItem(catalog.getProduct("A001"), 5));
		orders[5].addItem(new OrderItem(catalog.getProduct("A004"), 4));
		sales.addOrder(orders[5]);
		
		return sales;
	}
	private void run() throws IOException  {

		int  choice = getChoice();

		while (choice != 0)  {

			if (choice == 1)  {
				displayCatalog();
			} else if (choice == 2)  {
				displayProductInfo();
			} else if (choice == 3)  {
				displayOrder();
			} else if (choice == 4)  {
				addModifyProduct();
			} else if (choice == 5)  {
				removeProduct();
			} else if (choice == 6)  {
				saleOrder();
			} else if (choice == 7)  {
				displayOrdersSold();
			} else if (choice == 8)  {
				displayNumberOfOrders(readProduct());
			} else if (choice == 9)  {
				displayTotalQuantityOfProducts();
			} 

			choice = getChoice();
		}
	}
	private int  getChoice() throws IOException  {

		int  input;

		do  {
			try  {
				stdErr.println();
				stdErr.print(
					  "[0] Quit\n"
					+ "[1] Display catalog\n"
					+ "[2] Display product\n"
					+ "[3] Display current order\n"
					+ "[4] Add|modify product to|in current order\n"
					+ "[5] Remove product from current order\n"
					+ "[6] Register sale of current order\n"
					+ "[7] Display sales\n"
					+ "[8] Display number of orders with a specific product\n"
					+ "[9] Display the total quantity sold for each product\n"
					+ "choice> ");
				stdErr.flush();

				input = Integer.parseInt(stdIn.readLine());

				stdErr.println();

				if (0 <= input && 9 >= input)  {
					break;
				} else {
					stdErr.println("Invalid choice:  " + input);
				}
			} catch (NumberFormatException  nfe)  {
				stdErr.println(nfe);
			}
		}  while (true);

		return  input;
	}
	public void displayCatalog() {

		int size = this.catalog.getNumberOfProducts();

		if (size == 0) {
			stdErr.println("The catalog is empty");
		} else {
			for (Product  product : this.catalog) {

				stdOut.println(product.getCode() + " " +
					product.getDescription());
			}
		}
	}
	public void displayProductInfo() throws IOException  {

		Product product = readProduct();

		stdOut.println("  Description: " + product.getDescription());
		stdOut.println("  Price: " + product.getPrice());
		if (product instanceof Coffee) {

			Coffee coffee = (Coffee) product;

			stdOut.println("  Origin: " + coffee.getOrigin());
			stdOut.println("  Roast: " + coffee.getRoast());
			stdOut.println("  Flavor: " + coffee.getFlavor());
			stdOut.println("  Aroma: " + coffee.getAroma());
			stdOut.println("  Acidity: " + coffee.getAcidity());
			stdOut.println("  Body: " + coffee.getBody());
		} else if (product instanceof CoffeeBrewer) {

			CoffeeBrewer brewer = (CoffeeBrewer) product;

			stdOut.println("  Model: " + brewer.getModel());
			stdOut.println("  Water Supply: " + brewer.getWaterSupply());
			stdOut.println("  Number of Cups: " + brewer.getNumberOfCups());
		}
	}
	public void displayOrder() {

		int size = this.currentOrder.getNumberOfItems();

		if (size == 0) {
			stdErr.println("The current order is empty");
		} else {
			for (OrderItem  orderItem : this.currentOrder) {
				stdOut.println(orderItem.toString());
			}
			stdOut.println("Total: " +
				CURRENCY.format(this.currentOrder.getTotalCost()));
		}
	}
	public void addModifyProduct()  throws IOException  {

		Product product = readProduct();
		int quantity = readQuantity();
		OrderItem orderItem = this.currentOrder.getItem(product);

		if (orderItem == null) {
			this.currentOrder.addItem(new OrderItem(product, quantity));
			stdOut.println("The product " + product.getCode()
			 + " has been added");
		} else {
			orderItem.setQuantity(quantity);
			stdOut.println("The quantity of the product " +
				product.getCode() + " has been modified");
		}
	}
	public void removeProduct()  throws IOException  {

		Product product = readProduct();
		OrderItem orderItem = this.currentOrder.getItem(product);

		if (orderItem != null) {
			this.currentOrder.removeItem(orderItem);
			stdOut.println("The product " + product.getCode()
				 + " has been removed from the current order");
		} else {
			stdErr.println(
				"There are no products in the current order with that code");
		}
	}
	public void saleOrder()  {

		if (this.currentOrder.getNumberOfItems() > 0) {
			this.sales.addOrder(this.currentOrder);
			this.currentOrder = new Order();
			stdOut.println("The sale of the order has been registered");
		} else {
			stdErr.println("The current order is empty");
		}
	}
	public void displayOrdersSold() {

		int numOrders = this.sales.getNumberOfOrders();

		if (numOrders != 0) {
			int orderNumber = 1;
			for (Order  order : this.sales) {

				stdOut.println("Order " + orderNumber++);

				for (OrderItem  orderItem : order) {
					stdOut.println("   " + orderItem.toString());
				}
				stdOut.println("   Total: " +
					CURRENCY.format(order.getTotalCost()));
			}
		} else {
			stdErr.println("There are no sales");
		}
	}
	public void displayNumberOfOrders(Product product) {
		int total = 0;
		for(Order order:sales) {
			for(OrderItem orderItem:order) {
				if(orderItem.getProduct().equals(product)) {
					total++;
					break;
				}
			}
		}
		System.out.println("Number of orders that contains the product "+product.getCode()+": "+total);
	}
	public void displayTotalQuantityOfProducts() {

		/* PLACE YOUR CODE HERE */
		for(Product product:catalog) {
			int total = 0;
			for(Order order:sales) {
				for(OrderItem orderItem:order) {
					if(orderItem.getProduct().equals(product)) {
						total+=orderItem.getQuantity();
					}
				}
			}
			System.out.println(product.getCode()+": "+total);
		}
	}
	private Product readProduct() throws IOException  {

		do  {			
			stdErr.print("Product code> ");
			stdErr.flush();
			
			Product product = this.catalog.getProduct(stdIn.readLine());
			
			if (product != null) {

				return product;
			
			} else {	
				stdErr.println("There are no products with that code");
			}
		}  while (true);
	}
	private int readQuantity() throws IOException  {

		int quantity;

		do  {
			try  {

				stdErr.print("Quantity> ");
				stdErr.flush();
				quantity = Integer.parseInt(stdIn.readLine());
				if (quantity > 0) {

					return quantity;

				} else  {
					stdErr.println(
						"Invalid input. Please enter a positive integer");
				}
			} catch (NumberFormatException  nfe)  {
				stdErr.println(nfe);
			}
		}  while (true);
	}
}

又水了点代码，这回作业考察了iterator和arraylist，总体来说难度也不是很高