7-1 菜单计价程序-4_菜单计价程序-3-CSDN博客

本文链接：https://blog.csdn.net/hatervail/article/details/130342930

该文描述了一个使用Java编写的菜单计价程序，程序需处理多种异常情况，如菜谱与订单混合、时间格式错误、份额和份数超出范围等。程序涉及Dish、Menu、Order和Record等类的设计，以及折扣计算和代点菜功能。输入包括菜谱信息、桌号、订单记录等，输出包括每桌的订单处理信息和总价。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

7-1 菜单计价程序-4

在列代码之前讲一个好笑的事情：

根据传闻，写菜单系列题目4的时候，老段曾问过蔡柯这样一个问题：你花了多久写这道题目？

蔡：大概一个星期吧。

段：那你让我学生怎么办？

下面接入正题：（作者水平有限，只写到了88分，后面还有几个测试点貌似要去检测输入的table）

7-1 菜单计价程序-4

分数 100

全屏浏览题目

切换布局

作者蔡轲

单位南昌航空大学

本体大部分内容与菜单计价程序-3相同，增加的部分用加粗文字进行了标注。

设计点菜计价程序，根据输入的信息，计算并输出总价格。

输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

菜单由一条或多条菜品记录组成，每条记录一行

每条菜品记录包含：菜名、基础价格两个信息。

订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。

桌号标识独占一行，包含两个信息：桌号、时间。

桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。

点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。

不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。

删除记录格式：序号 delete

标识删除对应序号的那条点菜记录。

如果序号不对，输出"delete error"

代点菜信息包含：桌号序号菜品名称份额分数

代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。

程序最后按输入的桌号从小到大的顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。

每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。

折扣的计算方法（注：以下时间段均按闭区间计算）：

周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。

周末全价，营业时间：9:30-21:30

如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"

参考以下类的模板进行设计（本内容与计价程序之前相同，其他类根据需要自行定义）：

菜品类：对应菜谱上一道菜的信息。

Dish {

String name;//菜品名称

int unit_price; //单价

int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

Menu {

Dish[] dishs ;//菜品数组，保存所有菜品信息

Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。

Dish addDish(String dishName,int unit_price)//添加一道菜品信息

}

点菜记录类：保存订单上的一道菜品记录

Record {

int orderNum;//序号

Dish d;//菜品\\

int portion;//份额（1/2/3代表小/中/大份）

int getPrice()//计价，计算本条记录的价格

}

订单类：保存用户点的所有菜的信息。

Order {

Record[] records；//保存订单上每一道的记录

int getTotalPrice()//计算订单的总价

Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。

delARecordByOrderNum(int orderNum)//根据序号删除一条记录

findRecordByNum(int orderNum)//根据序号查找一条记录

}

本次课题比菜单计价系列-3增加的异常情况：

1、菜谱信息与订单信息混合，应忽略夹在订单信息中的菜谱信息。输出："invalid dish"

2、桌号所带时间格式合法（格式见输入格式部分说明，其中年必须是4位数字，月、日、时、分、秒可以是1位或2位数），数据非法，比如：2023/15/16 ，输出桌号＋" date error"

3、同一桌菜名、份额相同的点菜记录要合并成一条进行计算，否则可能会出现四舍五入的误差。

4、重复删除，重复的删除记录输出"deduplication :"+序号。

5、代点菜时，桌号不存在，输出"Table number ："+被点菜桌号+" does not exist"；本次作业不考虑两桌记录时间不匹配的情况。

6、菜谱信息中出现重复的菜品名，以最后一条记录为准。

7、如果有重复的桌号信息，如果两条信息的时间不在同一时间段，（时段的认定：周一到周五的中午或晚上是同一时段，或者周末时间间隔1小时（不含一小时整，精确到秒）以内算统一时段），此时输出结果按不同的记录分别计价。

8、重复的桌号信息如果两条信息的时间在同一时间段，此时输出结果时合并点菜记录统一计价。前提：两个的桌号信息的时间都在有效时间段以内。计算每一桌总价要先合并符合本条件的饭桌的点菜记录，统一计价输出。

9、份额超出范围（1、2、3）输出：序号+" portion out of range "+份额，份额不能超过1位，否则为非法格式，参照第13条输出。

10、份数超出范围，每桌不超过15份，超出范围输出：序号+" num out of range "+份数。份数必须为数值，最高位不能为0，否则按非法格式参照第16条输出。

11、桌号超出范围[1,55]。输出：桌号 +" table num out of range"，桌号必须为1位或多位数值，最高位不能为0，否则按非法格式参照第16条输出。

12、菜谱信息中菜价超出范围（区间（0,300）），输出：菜品名+" price out of range "+价格，菜价必须为数值，最高位不能为0，否则按非法格式参照第16条输出。

13、时间输入有效但超出范围[2022.1.1-2023.12.31]，输出："not a valid time period"

14、一条点菜记录中若格式正确，但数据出现问题，如：菜名不存在、份额超出范围、份数超出范围，按记录中从左到右的次序优先级由高到低，输出时只提示优先级最高的那个错误。

15、每桌的点菜记录的序号必须按从小到大的顺序排列（可以不连续，也可以不从1开始），未按序排列序号的输出："record serial number sequence error"。当前记录忽略。（代点菜信息的序号除外）

16、所有记录其它非法格式输入，统一输出"wrong format"

17、如果记录以“table”开头，对应记录的格式或者数据不符合桌号的要求，那一桌下面定义的所有信息无论正确或错误均忽略，不做处理。如果记录不是以“table”开头，比如“tab le 55 2023/3/2 12/00/00”，该条记录认为是错误记录，后面所有的信息并入上一桌一起计算。

本次作业比菜单计价系列-3增加的功能：

菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+基础价格+"T"

例如：麻婆豆腐 9 T

菜价的计算方法：

周一至周五 7折，周末全价。

注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：

计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。

最后将所有记录的菜价累加得到整桌菜的价格。

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+”:”

2、按顺序输出当前这一桌每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价

输入样例:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 1 2
2 delete
2 delete
end

输出样例:

在这里给出相应的输出。例如：

table 31: 
1 num out of range 16
2 油淋生菜 18
deduplication 2
table 31: 0 0

输入样例1:

份数超出范围+份额超出范围。例如：

麻婆豆腐 12
油淋生菜 9 T
table 31 2023/2/1 14/20/00
1 麻婆豆腐 1 16
2 油淋生菜 4 2
end

输出样例1:

份数超出范围+份额超出范围。例如：

table 31: 
1 num out of range 16
2 portion out of range 4
table 31: 0 0

输入样例2:

桌号信息错误。例如：

麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

输出样例2:

在这里给出相应的输出。例如：

wrong format

输入样例3:

混合错误：桌号信息格式错误+混合的菜谱信息（菜谱信息忽略）。例如：

麻婆豆腐 12
油淋生菜 9 T
table 55 2023/3/31 12/000/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

输出样例3:

在这里给出相应的输出。例如：

wrong format

输入样例4:

错误的菜谱记录。例如：

麻婆豆腐 12.0
油淋生菜 9 T
table 55 2023/3/31 12/00/00
麻辣香锅 15
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

输出样例4:

在这里给出相应的输出。例如：

wrong format
table 55: 
invalid dish
麻婆豆腐 does not exist
2 油淋生菜 14
table 55: 14 10

输入样例5:

桌号格式错误（以“table”开头）+订单格式错误（忽略）。例如：

麻婆豆腐 12
油淋生菜 9 T
table a 2023/3/15 12/00/00
1 麻婆 豆腐 1 1
2 油淋生菜 2 1
end

输出样例5:

在这里给出相应的输出。例如：

wrong format

输入样例6:

桌号格式错误，不以“table”开头。例如：

麻婆豆腐 12
油淋生菜 9 T
table 1 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
tab le 2 2023/3/15 12/00/00
1 麻婆豆腐 1 1
2 油淋生菜 2 1
end

输出样例6:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 12
2 油淋生菜 14
wrong format
record serial number sequence error
record serial number sequence error
table 1: 26 17

下面是详细的代码：


import java.text.ParseException;
import java.time.DateTimeException;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	public static boolean isNumeric(String string) {
		int intValue;
		try {
			intValue = Integer.parseInt(string);
			return true;
		} catch (NumberFormatException e) {
			return false;
		}
	}

	public static void main(String[] args) throws ParseException {
		Menu menu = new Menu();
		ArrayList<Table> tables = new ArrayList<Table>();
		Scanner input = new Scanner(System.in);
		String str1 = new String();
		int i = 0;
		int portion = 0, quota = 0;
		while (true) {// 输入菜单
			Dish temp = new Dish();
			int isRepeat = -1;
			str1 = input.nextLine();
			if (str1.matches("[\\S]* [1-9][\\d]*")) {
				String[] token = str1.split(" ");
				temp.name = token[0];
				temp.unit_price = Integer.parseInt(token[1]);
				if (temp.unit_price > 300) {
					System.out.println(temp.name + " price out of range " + temp.unit_price);
					continue;
				}
				temp.isT = false;
				isRepeat = menu.searchDish(temp.name);
				if (isRepeat != -1) {
					menu.dishs.remove(isRepeat);
				}
				menu.dishs.add(temp);
			} else if (str1.matches("[\\S]* [\\d]* T")) {
				String[] token = str1.split(" ");
				temp.name = token[0];
				temp.unit_price = Integer.parseInt(token[1]);
				if (temp.unit_price > 300) {
					System.out.println(temp.name + " price out of range " + temp.unit_price);
					continue;
				}
				temp.isT = true;
				if (isRepeat != -1) {
					menu.dishs.remove(isRepeat);
				}
				menu.dishs.add(temp);
			} else if (str1.equals("end")) {
				break;
			} else if (str1.matches("tab.*")) {
				break;

			} else {
				System.out.println("wrong format");
				continue;
			}
		}
		while (!str1.equals("end")) {
			Table temp = new Table();
			boolean isRepeat = false;
			int repeatNum = 0;
			if (str1.matches("table.*")) {
				if (str1.matches("table [1-9][\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?")) {
					String[] token = str1.split(" ");
					String[] Date = token[2].split("/");
					String[] Time = token[3].split("/");
					int[] intDate = new int[3];
					int[] intTime = new int[3];
					for (i = 0; i < 3; i++) {
						intDate[i] = Integer.parseInt(Date[i]);
						intTime[i] = Integer.parseInt(Time[i]);
					}
					temp.num = Integer.parseInt(token[1]);
					if (temp.num > 55) {
						System.out.println(temp.num + " table num out of range");
						str1 = input.nextLine();
						continue;

					}
					try {
						temp.time = LocalDateTime.of(intDate[0], intDate[1], intDate[2], intTime[0], intTime[1],
								intTime[2]);
						temp.getWeekDay();
					} catch (DateTimeException e) {
						System.out.println(temp.num + " date error");
						str1 = input.nextLine();
						continue;
					}
					if (!(temp.time.isAfter(LocalDateTime.of(2022, 1, 1, 0, 0, 0))
							&& temp.time.isBefore(LocalDateTime.of(2024, 1, 1, 0, 0, 0)))) {
						System.out.println("not a valid time period");
						str1 = input.nextLine();
						continue;
					}
					// 判断桌号是否重复
					if (temp.isOpen()) {
						for (i = 0; i < tables.size(); i++) {
							// 有重复的桌号
							if (temp.num == tables.get(i).num && tables.get(i).isOpen()) {
								Duration duration = Duration.between(temp.time, tables.get(i).time);
								// 同一天
								if (duration.toDays() == 0) {
									// 在周一到周五
									if (temp.weekday > 0 && temp.weekday < 6) {
										// 在同一时间段
										if (temp.time.getHour() < 15 && tables.get(i).time.getHour() < 15) {
											temp = tables.get(i);
											isRepeat = true;
											repeatNum = i;
											break;
										}
									}
									// 在周末
									else {
										// 时间相差小于一小时
										if (duration.toHours() < 3600) {
											temp = tables.get(i);
											repeatNum = i;
											isRepeat = true;
											break;
										}
									}
								}
							}
						}
					}
					if(!isRepeat) {
						System.out.println("table " + temp.num + ": ");
					}
					
				}
				else {
					System.out.println("wrong format");
					str1 = input.nextLine();
					continue;
				}
				// 本桌开始点菜
				while (true) {
					str1 = input.nextLine();
					if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
						String[] token = str1.split(" ");
						portion = Integer.parseInt(token[2]);
						quota = Integer.parseInt(token[3]);
						if (temp.order.records.size() > 0) {
							if (Integer.parseInt(
									token[0]) <= temp.order.records.get(temp.order.records.size() - 1).orderNum) {
								System.out.println("record serial number sequence error");
								continue;
							}
						}
						if (menu.searchDish(token[1]) == -1) {
							System.out.println(token[1] + " does not exist");
							continue;
						}
						if (portion > 3 || portion < 1) {
							System.out.println(Integer.parseInt(token[0]) + " portion out of range " + portion);
							continue;
						}
						if (quota > 15) {
							System.out.println(Integer.parseInt(token[0]) + " num out of range " + quota);
							continue;
						}
						temp.od(menu, token[0], token[1], portion, quota);
					}
					// 判断是否为删除订单
					else if (str1.matches("[1-9][\\d]* delete")) {
						String[] token = str1.split(" ");
						temp.order.delARecordByOrderNum(Integer.parseInt(token[0]));
					}
					// 判断是否为夹杂菜单
					else if (str1.matches("[\\S]* [\\d]*")) {
						System.out.println("invalid dish");
						continue;
					} else if (str1.matches("[\\S]* [\\d]* T")) {
						System.out.println("invalid dish");
						continue;
					}
					// 判断是否为代点
					else if (str1.matches("[\\d]* [\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
						String[] token = str1.split(" ");
						// 判断代点桌号是否存在
						boolean exist = false;
						for (int j = 0; j < tables.size(); j++) {
							if (tables.get(j).num == Integer.parseInt(token[0])) {
								exist = true;
								break;
							}
						}
						if (exist) {
							System.out.print(Integer.parseInt(token[1]) + " table " + temp.num + " pay for table "
									+ Integer.parseInt(token[0]) + " ");
							Record treat = new Record();
							treat.d = menu.dishs.get(menu.searchDish(token[2]));
							portion = Integer.parseInt(token[3]);
							quota = Integer.parseInt(token[4]);
							treat.portion = portion;
							treat.quota = quota;
							System.out.print(treat.getPrice() + "\n");
							temp.sum += treat.getPrice();
						}
						// 若不存在则输出内容
						else {
							System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
						}

					} else if (str1.equals("end")) {
						break;
					} else if(str1.matches("ta.*")){
						break;
						
					}
					else {
						System.out.println("wrong format");
						continue;
					}
				}
			} else if (str1.matches("t.*")) {
				isRepeat = true;
				temp = tables.get(tables.size());
				while (true) {
					str1 = input.nextLine();
					if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
						String[] token = str1.split(" ");
						portion = Integer.parseInt(token[2]);
						quota = Integer.parseInt(token[3]);
						// 判断订单号是否由小到大排列
						if (temp.order.records.size() > 0) {
							if (Integer.parseInt(
									token[0]) <= temp.order.records.get(temp.order.records.size() - 1).orderNum) {
								System.out.println("record serial number sequence error");
								continue;
							}
						}
						if (menu.searchDish(token[1]) == -1) {
							System.out.println(token[1] + " does not exist");
							continue;
						}
						if (portion > 3 || portion < 1) {
							System.out.println(Integer.parseInt(token[0]) + " portion out of range " + portion);
							continue;
						}
						if (quota > 15) {
							System.out.println(Integer.parseInt(token[0]) + " num out of range " + quota);
							continue;
						}
						temp.od(menu, token[0], token[1], portion, quota);
					}
					// 判断是否为删除订单
					else if (str1.matches("[1-9][\\d]* delete")) {
						String[] token = str1.split(" ");
						temp.order.delARecordByOrderNum(Integer.parseInt(token[0]));
					}
					// 判断是否为夹杂菜单
					else if (str1.matches("[\\S]* [\\d]*")) {
						System.out.println("invalid dish");
						continue;
					} else if (str1.matches("[\\S]* [\\d]* T")) {
						System.out.println("invalid dish");
						continue;
					}
					// 判断是否为代点
					else if (str1.matches("[\\d]* [\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
						String[] token = str1.split(" ");
						// 判断代点桌号是否存在
						boolean exist = false;
						for (int j = 0; j < tables.size(); j++) {
							if (tables.get(j).num == Integer.parseInt(token[0])) {
								exist = true;
								break;
							}
						}
						if (exist) {
							System.out.print(Integer.parseInt(token[1]) + " table " + temp.num + " pay for table "
									+ Integer.parseInt(token[0]) + " ");
							Record treat = new Record();
							treat.d = menu.dishs.get(menu.searchDish(token[2]));
							portion = Integer.parseInt(token[3]);
							quota = Integer.parseInt(token[4]);
							treat.portion = portion;
							treat.quota = quota;
							System.out.print(treat.getPrice() + "\n");
							temp.sum += treat.getPrice();
						}
						// 若不存在则输出内容
						else {
							System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
						}

					} else if (str1.equals("end")) {
						break;
					} else {
						System.out.println("wrong format");
						continue;
					}
				}
				if (tables.size() != 0) {
					tables.get(tables.size() - 1).order.records.addAll(temp.order.records);
				}
			} else {
				str1 = input.nextLine();
				continue;
			}

			// 本桌点菜结束，进入下一桌
			if (isRepeat) {
				tables.remove(repeatNum);
			}
			temp.getSum();
			tables.add(temp);
		}
		// 最终输出桌号订单信息
		for (i = 0; i < tables.size(); i++) {
			if (tables.get(i).isOpen()) {
				System.out
						.println("table " + tables.get(i).num + ": " + tables.get(i).origSum + " " + tables.get(i).sum);
			} else
				System.out.println("table " + tables.get(i).num + " out of opening hours");
		}
	}

	static class Dish {
		String name;
		int unit_price;
		boolean isT = false;
	}

	static class Record {
		int orderNum;
		Dish d;
		int portion;
		int quota;
		boolean isDeleted = false;

		int getPrice() {
			if (portion == 2)
				return (int) Math.round(1.5 * d.unit_price) * quota;
			else if (portion == 3)
				return 2 * d.unit_price * quota;
			else
				return d.unit_price * quota;
		}
	}

	static class Menu {
		ArrayList<Dish> dishs = new ArrayList<Dish>();

		int searchDish(String dishName) {
			for (int i = 0; i < dishs.size(); i++) {
				if (dishName.equals(dishs.get(i).name)) {
					return i;
				}
			}
			return -1;
		}

		Dish addDish(String dishName, int unit_price) {
			Dish newDish = new Dish();
			newDish.name = dishName;
			newDish.unit_price = unit_price;
			return newDish;
		}
	}

	static class Order {
//		Record[] records = new Record[20];
		ArrayList<Record> records = new ArrayList<Record>();

		Record addARecord(int orderNum, String dishName, int portion, int quota, Menu menu) {
			Record newRecord = new Record();
			newRecord.orderNum = orderNum;
			newRecord.d = menu.dishs.get(menu.searchDish(dishName));
			newRecord.portion = portion;
			newRecord.quota = quota;
			System.out.println(newRecord.orderNum + " " + newRecord.d.name + " " + newRecord.getPrice());
			return newRecord;
		}

		int searchReocrd(String name) {
			for (int i = 0; i < records.size(); i++) {
				if (records.get(i).d.name == name) {
					return i;
				}
			}
			return -1;
		}

		boolean delARecordByOrderNum(int orderNum) {
			int i = 0, flag = 0;
			for (i = 0; i < records.size(); i++) {
				if (records.get(i).orderNum == orderNum) {
					if (records.get(i).isDeleted == false) {
						records.get(i).isDeleted = true;
					} else {
						System.out.println("deduplication " + orderNum);
					}
					flag++;
				}
			}
			if (flag == 0) {
				System.out.println("delete error;");
				return false;
			}
			return true;
		}
	}

	static class Table {
		Order order = new Order();
		int num;
		LocalDateTime time;
		int weekday;
		long sum = 0;
		long origSum = 0;
		void od(Menu menu, String str1, String str2, int portion, int quota) {
			{
				order.records.add(order.addARecord(Integer.parseInt(str1), str2, portion, quota, menu));

			}
		}

		void getWeekDay() {
			weekday = time.getDayOfWeek().getValue();
		}

		void getSum() {
			for (int i = 0; i < order.records.size(); i++) {
				if (!order.records.get(i).isDeleted) {
					origSum += order.records.get(i).getPrice();
					if (order.records.get(i).d.isT) {
						if (weekday > 0 && weekday < 6) {
							sum += Math.round(order.records.get(i).getPrice() * 0.7);
						} 
						else {
							sum += order.records.get(i).getPrice();
						}
					}
					else 
					{
						if (weekday > 0 && weekday < 6) {
							if (time.getHour() >= 17 && time.getHour() < 20)
								sum += Math.round(order.records.get(i).getPrice() * 0.8);
							if (time.getHour() == 20) {
								if (time.getMinute() <= 30)
									sum += Math.round(order.records.get(i).getPrice() * 0.8);
							}
							if (time.getHour() >= 10 && time.getHour() < 14)
								sum += Math.round(order.records.get(i).getPrice() * 0.6);
							if (time.getHour() == 14) {
								if (time.getMinute() <= 30)
									sum += Math.round(order.records.get(i).getPrice() * 0.6);
							}
						}
						else sum+=order.records.get(i).getPrice();
					}
				}
			}

		}

		boolean isOpen() {
			if (weekday > 0 && weekday < 6) {
				if (time.getHour() >= 17 && time.getHour() < 20)
					return true;
				if (time.getHour() == 20) {
					if (time.getMinute() <= 30)
						return true;
				}
				if (time.getHour() > 10 && time.getHour() < 14)
					return true;
				if (time.getHour() == 10) {
					if (time.getMinute() >= 30)
						return true;
				}
				if (time.getHour() == 14) {
					if (time.getMinute() <= 30)
						return true;
				}
			} else {
				if (time.getHour() > 9 && time.getHour() < 21)
					return true;
				if (time.getHour() == 9) {
					if (time.getMinute() >= 30)
						return true;
				}
				if (time.getHour() == 21) {
					if (time.getMinute() <= 30)
						return true;
				}
			}
			return false;

		}
	}
}