Hi could you please separate different class you be creating so I can understand
ID: 3918803 • Letter: H
Question
Hi could you please separate different class you be creating so I can understand the code.
Create a Restaurant Order system. Create an abstract class called MenuItem.
Name of the item Description of the item Price Create an Appetizer that is derived from MenuItem Create a Soup that is derived from Appetizer Create three types of soups for your restaurant Create a Salad that is derived from Appetizer Create four types of salads for your restaurant Every salad has options for types of dressing.
Create an Entre that is derived from MenuItem An Entre include a main course Have at least three courses to choose from Give options of bread and two vegetable items An Entre item also has special instructions from the patron Create a Dessert that is derived from MenuItem Create two dessert options for your restaurant Create a Drink that is derived from Menuitem Create at least three drinks that can be ordered Create a Meal class Table number Seat number Drink Appetizer Entre Dessert The program should take an order for a patron. Nothing is required, but this system only allows one choice in each category.
Print an order for the bar that lists the table, seat and drink ordered. Print an order for the kitchen that lists the table, set, and each item ordered, along with any special instructions. Print a bill for the customer that lists the table, items ordered, their price. Total the prices and add a 5.5% sales tax and a 2% restaurant tax Give suggested tip amounts of 15%, 18%, and 20%
Explanation / Answer
The Restaurant Class:
package com.somitsolutions.training.java.restaurant;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
public class Restaurant {
private static final int MAX_NUMBER_OF_TABLES = 2;
private List<Table> mTables;
//whenever a new customer comes we add him to the front of this queue
private Deque<Customer> mCustomerQueue;
private Menu mMenu;
private List<Bill> billStore;
private static Restaurant mResturantObject = null;
private Customer currentCustomer;
private List<Customer> customerArray;
private Restaurant(){
mTables = new ArrayList<Table>();
mMenu = new Menu();
billStore = new ArrayList<Bill>();
mCustomerQueue = new ArrayDeque<Customer>(5);
customerArray = new ArrayList<Customer>();
currentCustomer = null;
for(int i = 0; i < MAX_NUMBER_OF_TABLES; i++){
Table t = new Table();
mTables.add(t);
}
}
public List<Table> getTables(){
return mTables;
}
public boolean isAnyTableOccupied(){
for(int i = 0; i < MAX_NUMBER_OF_TABLES; i++){
if (mTables.get(i).isOccupied() == true){
return true;
}
}
return false;
}
private int findTheEmptyTable(){
for(int i = 0; i < MAX_NUMBER_OF_TABLES; i++){
if(mTables.get(i).isOccupied() == false){
return i;
}
}
return -1;
}
public void displayOccupiedTable(){
for (int i = 0; i <MAX_NUMBER_OF_TABLES; i++){
if(mTables.get(i).isOccupied() == true){
System.out.println("Table No. " + i + " is occupied");
}
}
}
public boolean isAllTableOccupied(){
int val = findTheEmptyTable();
if (val == -1){
return true;
}
else {
return false;
}
}
public void bookATable(){
if(isAllTableOccupied() == false){
int tableNumber = findTheEmptyTable();
//get the customer from the list in the FIFO order
//and remove him from the queue
currentCustomer = mCustomerQueue.pollLast();
//set the customer id same as table id, because a customer is identified
//by the table which he occupies
currentCustomer.setCustomerId(tableNumber);
currentCustomer.getOrder().setOrderId(tableNumber);
customerArray.add(tableNumber, currentCustomer);
mTables.get(tableNumber).bookTable();
System.out.println(currentCustomer.getCustomerName() + " has been given table number: "+ tableNumber);
}
}
//input id is the customer id, which means it is nothing but the table id
public void generateBill(int id){
Customer customer = getCustomer(id);
Bill newBill = new Bill(id,customer);
billStore.add(newBill);
System.out.println("Total Amount:" + newBill.calculateTotal());
//return newBill.calculateTotal();
}
public Deque<Customer> getCustomerQueue() {
return mCustomerQueue;
}
public void setCustomerQueue(Deque<Customer> customerQueue) {
this.mCustomerQueue = customerQueue;
}
public Menu getMenu() {
return mMenu;
}
public void setMenu(Menu mMenu) {
this.mMenu = mMenu;
}
public void addNewCustomer(Customer customer){
//Customer newCustomer = new Customer();
mCustomerQueue.offerFirst(customer);
}
public static Restaurant getRestaurant(){
if(mResturantObject == null)
mResturantObject = new Restaurant();
return mResturantObject;
}
public Customer getCustomer(int id){
return customerArray.get(id);
}
public void releaseTable(int tableId){
if(mTables.get(tableId).isOccupied() == true){
mTables.get(tableId).releaseTable();
//mTables.remove(tableId);
System.out.println("Table number" + tableId + "is available now...");
}
if(mCustomerQueue.isEmpty() == false){
bookATable();
}
if ((mCustomerQueue.isEmpty() == true) && (isAnyTableOccupied() == true)){
System.out.println("There are still some customers...");
}
if ((mCustomerQueue.isEmpty() == true) && (isAnyTableOccupied() == false)){
System.out.println("All served...");
}
}
}
The Customer Class
package com.somitsolutions.training.java.restaurant;
public class Customer{
private int mCustomerId; //this is same as Table id. Each customer is identified
private Order mOrder;//by the table they occupied
private String mCustomerName;
public Customer(){
mCustomerId = 0;
mOrder = new Order(mCustomerId);
//addObserver(Restaurant.getRestaurant());
}
public Customer(int customerId){
mCustomerId = customerId;
mOrder = new Order(customerId);
}
public int getCustomerId() {
return mCustomerId;
}
public void setCustomerId(int mCustomerId) {
this.mCustomerId = mCustomerId;
}
public void giveOrder(Item item, int numberOfPlates){
//Order newOrder = new Order(mCustomerId);
ItemOrder newItemOrder = new ItemOrder(item, numberOfPlates);
mOrder.addOrder(newItemOrder);
}
public void iAmDone(){
}
public Order getOrder() {
return mOrder;
}
public void setOrder(Order mOrder) {
this.mOrder = mOrder;
}
public String getCustomerName() {
return mCustomerName;
}
public void setCustomerName(String mCustomerName) {
this.mCustomerName = mCustomerName;
}
}
The Menu Class
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Menu {
private List<Item> mMenu;
public Menu(){
mMenu = new ArrayList<Item>();
mMenu.add(new Item(11,"Tea", 5));
mMenu.add(new Item(22, "Coffee", 10));
mMenu.add(new Item(33, "Bread", 15));
}
public List<Item> getMenu(){
return mMenu;
}
public void display(){
int i = 0;
Iterator<Item> it = mMenu.iterator();
while(it.hasNext()){
Item currentItem = it.next();
System.out.println(i +": " +currentItem.getItemId() + " " + currentItem.getItemName() + " " + currentItem.getItemPrice());
i++;
}
}
}
The Item Class
public class Item {
private int mItemId;
private String mName;
private float mPrice;
public Item(){
}
public Item(int id, String name, float price){
mItemId = id;
mName = name;
mPrice = price;
}
public int getItemId() {
return mItemId;
}
public void setItemId(int mItemId) {
this.mItemId = mItemId;
}
public String getItemName() {
return mName;
}
public void setItemName(String mName) {
this.mName = mName;
}
public float getItemPrice() {
return mPrice;
}
public void setItemPrice(float mPrice) {
this.mPrice = mPrice;
}
}
The ItemOrder Class
public class ItemOrder {
private Item mItem;
private int mNumberOfPlates;
public ItemOrder(){
mItem = null;
mNumberOfPlates = 0;
}
public ItemOrder(Item item, int numberOfPlates){
mItem = item;
mNumberOfPlates = numberOfPlates;
}
public Item getItem() {
return mItem;
}
public void setItem(Item mItem) {
this.mItem = mItem;
}
public int getNumberOfPlates() {
return mNumberOfPlates;
}
public void setNumberOfPlates(int mNumberOfPlates) {
this.mNumberOfPlates = mNumberOfPlates;
}
}
The Order Class
import java.util.ArrayList;
import java.util.List;
public class Order {
private int mOrderId;//this is the same as customerId imagining
//that one customer will create only one order
private List<ItemOrder> mItemOrder = new ArrayList<ItemOrder>();
public Order(){
mOrderId = 0;
//mItemOrder = null;
}
public Order(int orderId){
mOrderId = orderId;
}
public List<ItemOrder> getItemOrder() {
return mItemOrder;
}
public void setItemOrder(List<ItemOrder> mItemOrder) {
this.mItemOrder = mItemOrder;
}
public int getOrderId() {
return mOrderId;
}
public void setOrderId(int mOrderId) {
this.mOrderId = mOrderId;
}
public void addOrder(ItemOrder itemOrder){
mItemOrder.add(itemOrder);
}
}
The Bill Class
import java.util.Iterator;
public class Bill {
//private Order mOrder;
private int mBillId;//this is the same as orderId
private Customer mCustomer;
public Bill(int Id, Customer customer){
mBillId = Id;
mCustomer = customer;
}
/*public Order getOrder() {
return mOrder;
}
public void setOrder(Order mOrder) {
this.mOrder = mOrder;
}*/
public float calculateTotal(){
float retValue = 0;
Iterator<ItemOrder> it = mCustomer.getOrder().getItemOrder().iterator();
while (it.hasNext() == true){
ItemOrder element = it.next();
retValue+= (element.getItem().getItemPrice())* (element.getNumberOfPlates());
}
return retValue;
}
public int getBillId() {
return mBillId;
}
public void setBillId(int mBillId) {
this.mBillId = mBillId;
}
}
The Table Class
public class Table {
private boolean mOccupied;
//private int mCustomerId;
public Table(){
mOccupied = false;
}
public boolean isOccupied(){
return
mOccupied == true;
}
public void bookTable(){
mOccupied = true;
}
public void releaseTable(){
mOccupied = false;
}
}
The Main RestaurantSystem Class
import java.util.Scanner;
public class RestaurantSystem {
public static void main(String[] args) {
Scanner myScan = new Scanner(System.in);
String s = "Y";
Restaurant restaurant = Restaurant.getRestaurant();
do{
int tableId = 0;
int customerId = 0;
Customer customer = null;
System.out.println("Is there a new customer?");
String ans = myScan.nextLine();
if(ans.equalsIgnoreCase("Y")){
customer = new Customer();
System.out.println("Please enter customer name...");
String customerName = myScan.nextLine();
customer.setCustomerName(customerName);
restaurant.addNewCustomer(customer);
if(restaurant.isAllTableOccupied() == false){
restaurant.bookATable();
restaurant.getMenu().display();
System.out.println("Choose Menu from the above List");
System.out.println("How many items do you want to order?");
int number_of_items = myScan.nextInt();
for (int i = 0; i<number_of_items; i++){
System.out.println("Choose from the numbers at the leftmost position");
int item_position = myScan.nextInt();
System.out.println("How many plates of menu item " + item_position + " you want to order");
int number_of_plates = myScan.nextInt();
if(i == number_of_items - 1){
myScan.nextLine();
}
Item item = restaurant.getMenu().getMenu().get(item_position);
customer.giveOrder(item, number_of_plates);
}
}
else {
System.out.println("Sorry all tables are occupied... Please wait...");
System.out.println("Has anybody finished?");
System.out.println("Occupied tables are:");
Restaurant.getRestaurant().displayOccupiedTable();
System.out.println("Enter -9 if noone has finished...");
tableId = Integer.parseInt(myScan.nextLine());
//customerId = Integer.parseInt(myScan.nextLine());
//Customer customerDone = restaurant.getCustomer(customerId);
//customerDone.iAmDone();
if(tableId != -9 ){
restaurant.generateBill(tableId);
restaurant.releaseTable(tableId);
}
}
}
else {
if(restaurant.isAnyTableOccupied() == true){
//System.out.println("There are still some customers");
System.out.println("Has anybody finished?");
System.out.println("Enter -9 if noone has finished...");
System.out.println("Occupied tables are:");
Restaurant.getRestaurant().displayOccupiedTable();
int numberTable = myScan.nextInt();
myScan.nextLine();
if(numberTable != -9){
restaurant.generateBill(numberTable);
restaurant.releaseTable(numberTable);
}
}
}
System.out.println("Do you want to continue?");
s = myScan.nextLine();
if(s.equalsIgnoreCase("N")){
System.exit(0);
}
}while (s.equalsIgnoreCase("Y"));
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.