一.前言
这次是对之前发布的PTA题目集4、5、6以及期中考试的总结。
题目集4有两个题目，是菜单计价程序-2和菜单计价程序-3，难度较后面的题目来说相对简单，但是我当时还是觉得不简单。题目集5、6都只有一个题目，分别是菜单计价程序-4和菜单计价程序-5，是菜单计价程序的最后两个题目，难度最大。从知识点方面来说，菜单菜单计价程序-4相对于之前的题目在异常情况处理、数据整合与合并、输出结果规范等方面有所加大，考察了我们对于异常情况处理的能力以及对订单数据处理的逻辑能力。此外，对特色菜的折扣计价方法也增加了一定的知识点难度。因此，相较于之前的题目，这道题目的难度相对更高，需要我们具备更加丰富的知识储备和逻辑分析能力。
期中考试的题目有四个，分别是测验1-圆类设计，测验2-类结构设计，测验3-继承与多态，测验4-抽象类与接口。层层递进的，不断迭代。和菜单系列的题目相比，当然期中考试的题目更为简单。
测试1的难度属于简单的，都是基础。
测试2的难度也很简单，其实测试3的难度也不大，主要考察的还是类的创建，继承关系和多态的应用。
测试4的难度就属于中等偏上了，因为我对接口的应用这部分知识还不熟悉。
二.设计与分析
7-1 菜单计价程序-2
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
点菜记录包含：序号、菜名、份额、份数。
份额可选项包括：1、2、3，分别代表小、中、大份。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
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)//根据序号查找一条记录
}
输入格式:
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
最后一条记录以“end”结束。
输出格式:
按顺序输出每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后输出订单上所有菜品的总价（整数数值），
本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。
代码如下：
import java.util.Scanner;
class Dish{
String name;//菜品名称
int unit_price;//单价
int fenshu;
int getPrice(int portion){
int price_1 = 0;
switch(portion){
case 1:
price_1=unit_price * fenshu;
break;
case 2:
price_1=(int) Math.round((double) (unit_price*1.5)) * fenshu;
break;
case 3:
price_1=unit_price*2*fenshu;
break;
}
return price_1;
}
}
class Menu{
Dish[] dishs =new Dish[100];//菜品数组，保存所有菜品信息
int count=0;
Dish searthDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish te=null;
for(int i=0;i<100;i++){
if(dishName.equals(dishs[i].name)){
//flag=1;
te=dishs[i];
break;
}
else
te=null;
}
//if(te==null)
//System.out.println(dishName+" does not exist");
return te;
}
Dish addDish(String dishName,int unit_price){
//添加一道菜品信息
Dish a=new Dish();
a.name=dishName;
a.unit_price=unit_price;
//count++;
return a;
}
}
class Record{
int orderNum;//序号\
Dish d=new Dish();//菜品\
int exist=1;
int portion;//份额（1/2/3代表小/中/大份）\
int getPrice(){//计价，计算本条记录的价格\
return d.getPrice(portion);
}
}
class Order{
Record[] records=new Record[100];//保存订单上每一道的记录
int count=0,sum=0;
int getTotalPrice(){//计算订单的总价
for(int i=0;i<count;i++){
if(records[i].exist==0)
continue;
sum+=records[i].getPrice();
}
return sum;
}
Record addARecord(int orderNum,String dishName,int portion,int num){//添加一条菜品信息到订单中。
Record b=new Record();
b.orderNum=orderNum;
b.d.name=dishName;
b.portion=portion;
b.d.fenshu=num;
count++;
return b;
}
boolean delARecordByOrderNum(int orderNum){
if(orderNum>count||orderNum<=0)
return false;
else
records[orderNum-1].exist=0;
return true;
}
}
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
Menu me = new Menu();
Order or = new Order();
int j=0,k=0;
Dish df = null;
while(true){
int co=0;
String s = input.nextLine();
for(int i=0;i<s.length();i++){
String te = s.substring(i,i+1);
if(te.equals(" ")){
co++;
}
}
if(s.equals("end"))
break;
if(co==1){
String[] arry = s.split(" ");
if(arry[1].equals("delete")){
int s4=Integer.parseInt(arry[0]);
if(!or.delARecordByOrderNum(s4)){
System.out.println("delete error;");
}
}else{
me.dishs[k] = me.addDish(arry[0],Integer.parseInt(arry[1]));
k++;
}
}
if(co==3){
String[] arry1 = s.split(" ");
int s1=Integer.parseInt(arry1[0]);
int s2=Integer.parseInt(arry1[2]);
int s3=Integer.parseInt(arry1[3]);
or.records[j]=or.addARecord(s1,arry1[1],s2,s3);
df = me.searthDish(or.records[j].d.name);
if(df==null){
System.out.println(or.records[j].d.name+" does not exist");
}
else{
or.records[j].d.unit_price = df.unit_price;
System.out.println(or.records[j].orderNum+" "+or.records[j].d.name+" "+or.records[j].d.getPrice(or.records[j].portion));
}
j++;
}
}
System.out.print(or.getTotalPrice());
}
}
类图如下：
分析：
（1）类之间的关系：在Java程序设计中，类之间可以有不同的关系。要想让类A返回数值到类B，两个类之间必须要建立正确的关联，例如继承、实现接口或者依赖关系等。
（2）访问权限：Java类中的方法和属性具有访问权限控制。对于要返回的数据，需要保证其访问权限得到了限定，并根据需求选择合适的访问修饰符，如private、protected、public等。
（3）返回值类型和参数传递：Java中方法可以定义返回值类型和参数列表。对于要返回的数值，需要在方法的定义中正确指定返回值类型，并将需要用到的参数正确传递给方法。
（4）实例化对象：将数值返回给另一个类时，还需要了解如何实例化另一个类的对象，从而能够直接使用该类的方法或属性。
7-2 菜单计价程序-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)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入格式:
桌号标识格式：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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
代码如下：
import java.util.Scanner;
class Dish{
String name;//菜品名称
int unit_price;//单价
int fenshu;
int getPrice(int portion){
int price_1 = 0;
switch(portion){
case 1:
price_1=unit_price * fenshu;
break;
case 2:
price_1=(int) Math.round((double) (unit_price*1.5)) * fenshu;
break;
case 3:
price_1=unit_price*2*fenshu;
break;
}
return price_1;
}
}
class Menu{
Dish[] dishs =new Dish[100];//菜品数组，保存所有菜品信息
int count=0;
Dish searthDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish te=null;
for(int i=0;i<100;i++){
if(dishName.equals(dishs[i].name)){
//flag=1;
te=dishs[i];
break;
}
else
te=null;
}
//if(te==null)
//System.out.println(dishName+" does not exist");
return te;
}
Dish addDish(String dishName,int unit_price){
//添加一道菜品信息
Dish a=new Dish();
a.name=dishName;
a.unit_price=unit_price;
//count++;
return a;
}
}
class Record{
int orderNum;//序号\
Dish d=new Dish();//菜品\
int exist=1;
int portion;//份额（1/2/3代表小/中/大份）\
int getPrice(){//计价，计算本条记录的价格\
return d.getPrice(portion);
}
}
class Order{
Record[] records=new Record[100];//保存订单上每一道的记录
int count=0,sum=0;
int getTotalPrice(){//计算订单的总价
for(int i=0;i<count;i++){
if(records[i].exist==0)
continue;
sum+=records[i].getPrice();
}
return sum;
}
Record addARecord(int orderNum,String dishName,int portion,int num){//添加一条菜品信息到订单中。
Record b=new Record();
b.orderNum=orderNum;
b.d.name=dishName;
b.portion=portion;
b.d.fenshu=num;
count++;
return b;
}
boolean delARecordByOrderNum(int orderNum){
if(orderNum>count||orderNum<=0)
return false;
else
records[orderNum-1].exist=0;
return true;
}
}
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
Menu me = new Menu();
Order or = new Order();
int j=0,k=0;
Dish df = null;
while(true){
int co=0;
String s = input.nextLine();
for(int i=0;i<s.length();i++){
String te = s.substring(i,i+1);
if(te.equals(" ")){
co++;
}
}
if(s.equals("end"))
break;
if(co==1){
String[] arry = s.split(" ");
if(arry[1].equals("delete")){
int s4=Integer.parseInt(arry[0]);
if(!or.delARecordByOrderNum(s4)){
System.out.println("delete error;");
}
}else{
me.dishs[k] = me.addDish(arry[0],Integer.parseInt(arry[1]));
k++;
}
}
if(co==3){
String[] arry1 = s.split(" ");
int s1=Integer.parseInt(arry1[0]);
int s2=Integer.parseInt(arry1[2]);
int s3=Integer.parseInt(arry1[3]);
or.records[j]=or.addARecord(s1,arry1[1],s2,s3);
df = me.searthDish(or.records[j].d.name);
if(df==null){
System.out.println(or.records[j].d.name+" does not exist");
}
else{
or.records[j].d.unit_price = df.unit_price;
System.out.println(or.records[j].orderNum+" "+or.records[j].d.name+" "+or.records[j].d.getPrice(or.records[j].portion));
}
j++;
}
}
System.out.print(or.getTotalPrice());
}
}
View Code
分析：
一开始先在菜单-2的基础上改，但是改到后面依旧很多报错索性又删了，参照网上的代码也没怎么看懂。加上当时没有留足够的时间去写菜单-3，没有认真完成，基本上没有改所以也没有什么分析。（提起菜单程序都是泪）
7-1 菜单计价程序-4
题目较长，就不复制过来了。
代码如下：
import java.util.Scanner;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;
public class Main {
public static void main(String[] args) {
Main main = new Main();
Scanner scanner = new Scanner(System.in);
ArrayList<String> messageList = new ArrayList<String>();
ArrayList<String> arrayList = new ArrayList<String>();
ArrayList<Table> tArrayList = new ArrayList<Main.Table>();
String string = "";
while (true) {
string = scanner.nextLine();
if ("end".equals(string)) {
break;
}
arrayList.add(string);
}
Menu menu = main.new Menu();
menu.dishs = new Dish[0];
int n = 0;
for (int i = 0; i < arrayList.size(); i++) {
String[] strings = arrayList.get(i).split(" ");
if (strings.length==0) {
break;
}
if (strings.length > 3&&strings[0].charAt(0)=='t') {
n = i;
break;
}else if(strings.length > 3){
continue;
}
String dName = strings[0];
String dPrice = strings[1];
if (dPrice.charAt(0) == '0') {
continue;
}
int hp = 0;
int sametime=0;
try {
hp = Integer.parseInt(dPrice);
} catch (Exception e) {
continue;
}
if (hp >= 300 || hp <= 0) {
continue;
}
if (menu.searthDish(dName) != null) {
for (int j = 0; j < menu.dishs.length; j++) {
if (menu.dishs[j].equals(dName)) {
menu.dishs[j].unit_price = hp;
}
}
} else {
Dish dish = main.new Dish();
if (strings.length == 2) {
dish.name = dName;
dish.unit_price = hp;
} else if (strings.length == 3) {
dish.name = dName;
dish.unit_price = hp;
dish.isT = true;
}
menu.addDish(dish);
}
}
ArrayList<Integer> arrayLista = new ArrayList<Integer>();// 桌号开始下标
for (int i = n; i < arrayList.size(); i++) {
if (arrayList.get(i).split(" ")[0].length() > 2 && arrayList.get(i).split(" ")[0].charAt(0) == 't') {
arrayLista.add(i);
}
}
for (int i = 0; i < arrayLista.size(); i++) {
Table table = main.new Table();
Order order = main.new Order();
order.records = new Record[0];
table.order = order;
int t1 = arrayLista.get(i);
String[] strings = arrayList.get(t1).split(" ");
if (strings.length==0) {
messageList.add("wrong format");
continue;
}
if (strings[0].equals("table")) {
if (strings[1].charAt(0) == '0') {
messageList.add("wrong format");
continue;
}
int tNum = 0;
try {
tNum = Integer.parseInt(strings[1]);
} catch (Exception e) {
messageList.add("wrong format");
continue;
}
if (tNum > 55 && tNum <= 0) {
messageList.add(tNum + " num out of range");
continue;
}
if (strings[2].split("/")[0].length() != 4) {// year
messageList.add("wrong format");
continue;
}
if (strings[2].split("/")[1].length() > 2 || strings[2].split("/")[1].length() < 1) {// month
messageList.add("wrong format");
continue;
}
if (strings[2].split("/")[2].length() > 2 || strings[2].split("/")[2].length() < 1) {// day
messageList.add("wrong format");
continue;
}
if (strings[3].split("/")[0].length() > 2 || strings[3].split("/")[0].length() < 1) {// hour
messageList.add("wrong format");
continue;
}
if (strings[3].split("/")[1].length() > 2 || strings[3].split("/")[1].length() < 1) {// minute
messageList.add("wrong format");
continue;
}
if (strings[3].split("/")[2].length() > 2 || strings[3].split("/")[2].length() < 1) {// moment
messageList.add("wrong format");
continue;
}
DateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
sdf.setLenient(false);
Date date = null;
try {
date = sdf.parse(strings[2] + " " + strings[3]);
} catch (ParseException e) {
messageList.add(tNum + " date error");
continue;
}
table.date = date;
table.tableNum = tNum;
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd");
SimpleDateFormat sdf2 = new SimpleDateFormat("HH/mm/ss");
Date date1 = null;
Date date2 = null;
try {
date1 = sdf1.parse("2022/1/1");
date2 = sdf1.parse("2023/12/31");
if (date1.compareTo(sdf1.parse(strings[2])) > 0 || date2.compareTo(sdf1.parse(strings[2])) < 0) {
messageList.add("not a valid time period");
continue;
}
} catch (ParseException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int dayNum = calendar.get(Calendar.DAY_OF_WEEK) - 1;
Date bdate = null;
Date edate = null;
Date bdate1 = null;
Date edate1 = null;
Date bdate2 = null;
Date edate2 = null;
Date nowDate = null;
try {
bdate = sdf2.parse("9/29/59");
edate = sdf2.parse("21/30/00");
bdate1 = sdf2.parse("10/30/00");
edate1 = sdf2.parse("14/30/00");
bdate2 = sdf2.parse("16/59/59");
edate2 = sdf2.parse("20/30/00");
nowDate = sdf2.parse(strings[3]);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (dayNum == 6 || dayNum == 0) {// 周末
if (timeCalendar(nowDate, bdate, edate)) {// 全价
table.dicount = 1.0;
} else {
messageList.add("table " + tNum + " out of opening hours");
continue;
}
} else {// 工作日
if (timeCalendar(nowDate, bdate1, edate1)) {// 6折
table.dicount = 0.6;
} else if (timeCalendar(nowDate, bdate2, edate2)) {// 8折
table.dicount = 0.8;
} else {
messageList.add("table " + tNum + " out of opening hours");
continue;
}
}
messageList.add("table"+" "+tNum + ": ");
if (t1 == arrayList.size()-1) {
} else {
int fNum;
if (arrayLista.get(arrayLista.size()-1) == t1) {
fNum = arrayList.size();
} else {
fNum = arrayLista.get(i + 1);
}
ArrayList<Integer> delNumArrayList = new ArrayList<Integer>();
int numb = 0;
for (int j = t1 + 1; j < fNum; j++) {// 点菜记录
String[] strings2 = arrayList.get(j).split(" ");
if (strings2.length==0) {
messageList.add("wrong format");
continue;
}
int Num1;
try {
Num1 = Integer.parseInt(strings2[0]);
} catch (Exception e) {
messageList.add("invalid dish");
continue;
}
if (strings2[0].charAt(0)=='0') {
messageList.add("wrong format");
continue;
}
if (strings2.length == 5) {// 代点菜
boolean flag = false;
if (tArrayList.get(0).tableNum == Num1)
flag = true;
if (flag) {
messageList.add("Table number ：" + Num1 + " does not exist");
continue;
}
if (strings2[3].length() > 1) {
messageList.add("wrong format");
continue;
} else {
String dishName = strings2[2];// 菜名
int dishP;
int dishN;
if (strings2[4].charAt(0) == '0') {
messageList.add("wrong format");
continue;
}
try {
dishP = Integer.parseInt(strings2[3]);
dishN = Integer.parseInt(strings2[4]);
} catch (Exception e) {
messageList.add("wrong format");
continue;
}
if (menu.searthDish(dishName) == null) {
messageList.add(dishName + " does not exist");
continue;
}
Dish dish = menu.searthDish(dishName);
if (dish.isT) {
if (dishP != 1 && dishP != 3&& dishP != 2) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
} else {
if (dishP != 1 && dishP != 3 && dishP != 2) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
}
if (dishN > 15 || dishN < 1) {
messageList.add(Num1 + " num out of range " + dishN);
continue;
}
boolean f1 = true;
if (f1) {
table.order.addARecord(Num1, dish, dishP, dishN);
}
}
} else if (strings2.length == 2) {
if (!strings2[1].equals("delete")) {
messageList.add("wrong format");
continue;
} else {
boolean flag = false;
for (Integer n2 : delNumArrayList) {
if (n2 == Num1) {
flag = true;
}
}
if (flag) {
messageList.add("deduplication " + Num1);
continue;
}
if (table.order.findRecordByNum(Num1) == -1) {
messageList.add("delete error");
continue;
}
table.order.delARecordByOrderNum(Num1);
delNumArrayList.add(Num1);
}
} else if (strings2.length == 4) {
if (strings2[2].length() > 1) {
messageList.add("wrong format");
continue;
} else {
String dishName = strings2[1];// 菜名
int dishP;
int dishN;
if (strings2[3].charAt(0) == '0') {
messageList.add("wrong format");
continue;
}
try {
dishP = Integer.parseInt(strings2[2]);
dishN = Integer.parseInt(strings2[3]);
} catch (Exception e) {
messageList.add("wrong format");
continue;
}
if (Num1 <= numb) {
messageList.add("record serial number sequence error");
continue;
}
if (menu.searthDish(dishName) == null) {
messageList.add(dishName + " does not exist");
continue;
}
Dish dish = menu.searthDish(dishName);
if (dish.isT) {
if (dishP != 1 && dishP != 3&& dishP != 2) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
} else {
if (dishP != 1 && dishP != 3 && dishP != 2) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
}
if (dishN > 15 || dishN < 1) {
messageList.add(Num1 + " num out of range " + dishN);
continue;
}
numb = Num1;
boolean f1 = true;
for (int k = 0; k < table.order.records.length; k++) {
if (table.order.records[k].d.name.equals(dishName)
&& table.order.records[k].portion == dishP) {
table.order.records[k].num = table.order.records[k].num + dishN;
f1 = false;
}
}
if (f1) {
table.order.addARecord(Num1, dish, dishP, dishN);
messageList.add(Num1 + " " + dishName + " " + dish.getPrice(dishP) * dishN);
}
}
} else {
messageList.add("wrong format");
continue;
}
}
}
} else {
messageList.add("wrong format");
if (t1 == arrayList.size()-1) {
} else {
int fNum;
if (arrayLista.get(arrayLista.size() - 1) == t1) {
fNum = arrayList.size();
} else {
fNum = arrayLista.get(i + 1)+1;
}
Table table2 = tArrayList.get(tArrayList.size()-1);
ArrayList<Integer> delNumArrayList = new ArrayList<Integer>();
int numb = table2.order.records[table2.order.records.length-1].orderNum;
for (int j = t1 + 1; j < fNum; j++) {// 点菜记录
String[] strings2 = arrayList.get(j).split(" ");
if (strings2.length==0) {
messageList.add("wrong format");
continue;
}
int Num1;
try {
Num1 = Integer.parseInt(strings2[0]);
} catch (Exception e) {
messageList.add("invalid dish");
continue;
}
if (strings2[0].charAt(0)=='0') {
messageList.add("wrong format");
continue;
}
if (strings2.length == 5) {// 代点菜
boolean flag = true;
for (int k = 0; k < tArrayList.size(); k++) {
if (tArrayList.get(k).tableNum == Num1) {
flag = false;
}
}
if (flag) {
messageList.add("Table number :" + Num1 + " does not exist");
continue;
}
if (strings2[3].length() > 1) {
messageList.add("wrong format");
continue;
} else {
String dishName = strings2[2];// 菜名
int dishP;
int dishN;
if (strings2[4].charAt(0) == '0') {
messageList.add("wrong format");
continue;
}
try {
dishP = Integer.parseInt(strings2[3]);
dishN = Integer.parseInt(strings2[4]);
} catch (Exception e) {
messageList.add("wrong format");
continue;
}
if (menu.searthDish(dishName) == null) {
messageList.add(dishName + " does not exist");
continue;
}
Dish dish = menu.searthDish(dishName);
if (dish.isT) {
if (dishP != 1 && dishP != 3) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
} else {
if (dishP != 1 && dishP != 3 && dishP != 2) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
}
if (dishN > 15 || dishN < 1) {
messageList.add(Num1 + " num out of range " + dishN);
continue;
}
boolean f1 = true;
if (f1) {
table2.order.addARecord(Num1, dish, dishP, dishN);
}
}
} else if (strings2.length == 2) {
if (!strings2[1].equals("delete")) {
messageList.add("wrong format");
continue;
} else {
boolean flag = false;
for (Integer n2 : delNumArrayList) {
if (n2 == Num1) {
flag = true;
}
}
if (flag) {
messageList.add("deduplication " + Num1);
continue;
}
if (table2.order.findRecordByNum(Num1) == -1) {
messageList.add("delete error");
continue;
}
table2.order.delARecordByOrderNum(Num1);
delNumArrayList.add(Num1);
}
} else if (strings2.length == 4) {
if (strings2[2].length() > 1) {
messageList.add("wrong format");
continue;
} else {
String dishName = strings2[1];// 菜名
int dishP;
int dishN;
if (strings2[3].charAt(0) == '0') {
messageList.add("wrong format");
continue;
}
try {
dishP = Integer.parseInt(strings2[2]);
dishN = Integer.parseInt(strings2[3]);
} catch (Exception e) {
messageList.add("wrong format");
continue;
}
if (Num1 <= numb) {
messageList.add("record serial number sequence error");
continue;
}
if (menu.searthDish(dishName) == null) {
messageList.add(dishName + " does not exist");
continue;
}
Dish dish = menu.searthDish(dishName);
if (dish.isT) {
if (dishP != 1 && dishP != 3) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
} else {
if (dishP != 1 && dishP != 3 && dishP != 2) {
messageList.add(Num1 + " portion out of range " + dishP);
continue;
}
}
if (dishN > 15 || dishN < 1) {
messageList.add(Num1 + " num out of range " + dishN);
continue;
}
numb = Num1;
boolean f1 = true;
for (int k = 0; k < table2.order.records.length; k++) {
if (table2.order.records[k].d.name.equals(dishName)
&& table2.order.records[k].portion == dishP) {
table2.order.records[k].num = table2.order.records[k].num + dishN;
f1 = false;
}
}
if (f1) {
table2.order.addARecord(Num1, dish, dishP, dishN);
messageList.add(Num1 + " " +dishName + " " + dish.getPrice(dishP) *dishN);
}
}
} else {
messageList.add("wrong format");
continue;
}
}
}
}
if (table.tableNum!=0) {
tArrayList.add(table);
}
}
for (int j = 0; j < messageList.size(); j++) {
System.out.println(messageList.get(j));
}
for (int j = 0; j < tArrayList.size()-1; j++) {
if (tArrayList.get(0).tableNum<tArrayList.get(1).tableNum) {
Table table = main.new Table();
table = tArrayList.get(1);
tArrayList.set(1, tArrayList.get(0));
tArrayList.set(0, table);
}
}
for (int j = 0; j < tArrayList.size(); j++) {
int tableNum = tArrayList.get(j).tableNum;
Order order =tArrayList.get(j).order;
int sum = 0;
int sumP = 0;
for (int i = 0; i < order.records.length; i++) {
Record record = order.records[i];
if (record.d.isT&&tArrayList.get(j).dicount!=1.0) {
sum +=(int)Math.round(record.getPrice());
sumP +=(int)Math.round(record.getPrice()*0.7);
}else {
sum +=record.getPrice();
sumP +=(int)Math.round(record.getPrice()*tArrayList.get(j).dicount);
}
}
if (j==tArrayList.size()-1) {
System.out.print("table"+" "+tableNum+":"+" "+sum+" "+sumP);
}else {
System.out.println("table"+" "+tableNum+":"+" "+sum+" "+sumP);
}
}
}
// 菜品类
class Dish {
String name;// 菜品名称
int unit_price; // 单价
boolean isT = false;
int getPrice(int portion) {// 计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
double money = 0;
switch (portion) {
case 1:// 小份
money = this.unit_price * 1.0;
break;
case 2:// 中份
money = 1.5 * this.unit_price;
break;
case 3:// 大份
money = this.unit_price * 2.0;
break;
}
return (int) Math.round(money);
}
}
// 菜谱类：对应菜谱，包含饭店提供的所有菜的信息
// 点菜记录类：保存订单上的一道菜品记录
class Record {
int orderNum;// 序号
Dish d;// 菜品
int portion;// 份额（1/2/3代表小/中/大份）
int num;// 份数
int getPrice() {// 计价，计算本条记录的价格
return (int) Math.round(this.d.getPrice(this.portion) * num);
}
}
class Menu {
Dish[] dishs;// 菜品数组，保存所有菜品信息
Dish searthDish(String dishName) {
for (int i = 0; i < dishs.length; i++) {
if (dishs[i].name.equals(dishName)) {
return dishs[i];
}
}
return null;
}
Dish addDish(Dish dish) {// 添加一道菜品信息
Dish[] dishs1 = new Dish[dishs.length + 1];
for (int i = 0; i < dishs.length; i++) {
dishs1[i] = dishs[i];
}
dishs1[dishs.length] = dish;
dishs = dishs1;
return dish;
}
}
// 订单类：保存用户点的所有菜的信息
class Order {
Record[] records;// 保存订单上每一道的记录
int getTotalPrice() {// 计算订单的总价
int sum = 0;
for (int i = 0; i < records.length; i++) {
sum += records[i].getPrice();
}
return sum;
}
// 添加一条菜品信息到订单中
Record addARecord(int orderNum, Dish dish, int portion, int num) {
Record record = new Record();
record.orderNum = orderNum;
record.d = dish;
record.portion = portion;
record.num = num;
Record[] records1 = new Record[this.records.length + 1];
for (int i = 0; i < this.records.length; i++) {
records1[i] = this.records[i];
}
records1[this.records.length] = record;
this.records = records1;
return record;
}
// 根据序号删除一条记录
void delARecordByOrderNum(int orderNum) {
int n = this.findRecordByNum(orderNum);
Record[] records1 = new Record[this.records.length - 1];
for (int i = 0; i < this.records.length; i++) {
if (i == n) {
continue;
}
if (i > n) {
records1[i] = this.records[i - 1];
} else {
records1[i] = this.records[i];
}
}
this.records = records1;
}
// 根据序号查找一条记录
int findRecordByNum(int orderNum) {
int n = -1;
for (int i = 0; i < this.records.length; i++) {
if (this.records[i].orderNum == orderNum) {
n = i;
}
}
return n;
}
}
class Table {
int tableNum;
Order order;
Date date;
double dicount = 0;
}
public static boolean timeCalendar(Date nowTime, Date beginTime, Date endTime) {
Calendar date = Calendar.getInstance();// 设置当前时间
date.setTime(nowTime);
Calendar begin = Calendar.getInstance();// 设置开始时间
begin.setTime(beginTime);// 开始时间
Calendar end = Calendar.getInstance();// 设置结束时间
end.setTime(endTime);// 上午结束时间
if ((date.after(begin) && date.before(end))) {// 判断是否处于开始时间之后和结束时间之前
return true;
} else {
return false;
}
}
}
View Code
类图如下：
分析：
这道题对我来说很难，题目也很长，看完题目后很懵感觉无法下手，毫无头绪。对点菜和代点菜的处理通过不断的异常抛出及捕捉将点菜和代点菜完成，其余由于格式错误，此时输入的数据要么是删菜要么是下一桌菜的信息要么是异常输入，由下一个catch异常捕捉处理。逻辑复杂性： 题目中需要处理菜单记录、订单记录、删除记录、代点菜信息，以及不同桌号的订单计算等，代码的逻辑结构可能会变得非常复杂。输入格式处理： 输入的格式很复杂，需要编写相应的输入解析代码来提取有效信息，同时进行格式验证和错误处理。
7-1 菜单计价程序-5
代码如下：
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.*;
public class Main{
public static void main(String args[]) {
int i = 0,j = 0,k = 0,f = 0,g =0,s,a = 0,b = 0,c = 0,flag = 0,flag1 = 0,flag2 = 0,flag3 = 0,flag4 = 0;
int dishNum = 0,discountPrice = 0;
int average =0;
Scanner input = new Scanner(System.in);
ArrayList<String> inputs = new ArrayList<>();
ArrayList<Customer> customers = new ArrayList<>();
int[] flags = new int[100];
double[] discount = new double[100];
double[] Specialdiscount = new double[100];
for(i = 0;i<100;i++) {
flags[i] = 0;
}
i = 0;
String in = input.nextLine();
while(!in.equals("end")) {
inputs.add(in);
in = input.nextLine();
}
inputs.add(in);//输入信息
Menu menu = new Menu();
ArrayList<Table> tables = new ArrayList<>();
while(!inputs.get(i).contains("table")) {
String[] dish = inputs.get(i).split(" ");//创建菜单
if(inputs.get(i).matches(".+\\s[\\d]+")) {
int price = Integer.parseInt(dish[1]);
menu.addDish(dish[0],price);//菜名和单价,往菜单里加一道菜
}
else if(inputs.get(i).matches(".+\\s.{2}\\s[\\d]+\\sT")){
int price = Integer.parseInt(dish[2]);
menu.addSpecialDish(dish[0],dish[1],price);
}
else System.out.println("wrong format");
i++;
}
int d = menu.dishs.size();
for(b = d - 1;b > 0;b--) {
for(c = b-1;c >= 0;c--) {
if(menu.dishs.get(b).name.equals(menu.dishs.get(c).name)) {
menu.dishs.remove(c);
}
}
}
while(!inputs.get(i).contains("end")) {
if(inputs.get(i).contains("table")) {
if(inputs.get(i).matches("table\\s.+\\s\\:\\s[\\w]{1,10}"
+ "\\s(180|181|189|133|135|136)[\\d]{8}"
+ "\\s[1-9][\\d]{3}/[\\d]{1,2}/[\\d]{1,2}\\s"
+ "[\\d]{1,2}/[\\d]{1,2}/[\\d]{1,2}"))
{
String[] tableInfo =inputs.get(i).split(" ");//创建桌子
int num = Integer.parseInt(tableInfo[1]);
String[] date = tableInfo[5].split("/");//时间
String[] time = tableInfo[6].split("/");//时间
int[] Date = new int[date.length];
int[] Time = new int[time.length];
for(k = 0;k < date.length;k++)
Date[k] = Integer.parseInt(date[k]);
for(k = 0;k < time.length;k++)
Time[k] = Integer.parseInt(time[k]);
Table table = new Table(tableInfo[1],tableInfo[3],tableInfo[4],tableInfo[5],tableInfo[6]);
tables.add(table);
j++;//桌子数增加
flag = 1;
a = 0;
if(Table.weekday(Date[0],Date[1],Date[2]) >= 1&&
Table.weekday(Date[0],Date[1],Date[2]) <= 5) {
Specialdiscount[j-1] = 0.7;
if((Time[0] >= 17&&Time[0]<=19)||(Time[0] == 20&&Time[1] <= 29)||
(Time[0] == 20&&Time[1] == 30&&Time[2] == 0)) {
discount[j-1] = 0.8;
System.out.println("table "+num+": ");
}
else if((Time[0] >= 11&&Time[0] <= 13)||
((Time[0] == 10||Time[0] == 14)&&Time[1] <= 29)||
((Time[0] == 10||Time[0] == 14)&&Time[1] == 30&&Time[2] == 0)) {
discount[j-1] = 0.6;
System.out.println("table "+num+": ");
}
else {
System.out.println("table " + num + " out of opening hours");
flags[f] = 1;
}
}
else if(Table.weekday(Date[0],Date[1],Date[2]) == 6||
Table.weekday(Date[0],Date[1],Date[2]) == 7) {
Specialdiscount[j-1] = 1;
if((Time[0] >= 10&&Time[0] <= 20)) {
discount[j-1] = 1;
System.out.println("table "+num+": ");
}
else if(((Time[0] == 10||Time[0] == 21)&&Time[1] <= 29)||
((Time[0] == 10||Time[0] == 21)&&Time[1] == 30&&Time[2]==0)){
discount[j-1] = 1;
//System.out.println("table "+num+": ");
}
else {
System.out.println("table " + num + " out of opening hours");
flags[f] = 1;
}
}
f++;
}
else {System.out.println("wrong format");
flag = 0;
}
}
else if(flag == 1&&flags[f-1]==0){
if(inputs.get(i).contains("delete")) {
String[] deletes = inputs.get(i).split(" ");
int num = Integer.parseInt(deletes[0]);
if(tables.get(j-1).getOrder().findRecordByNum(num)){//找到该记录
tables.get(j-1).getOrder().delARecordByOrderNum(num);
}
else {
System.out.println("delete error");
}
}
else {
String[] dishInfo =inputs.get(i).split(" ");//存入一条点菜记录
if(dishInfo.length == 4) {
int Num = Integer.parseInt(dishInfo[0]);//点菜序号
int portion = Integer.parseInt(dishInfo[2]);//份量
int number = Integer.parseInt(dishInfo[3]);//份数
if(menu.searthDish(dishInfo[1]) != -1) {//该菜品存在
tables.get(j-1).getOrder().addARecord(Num,
menu.dishs.get(menu.searthDish(dishInfo[1])),portion,number,discount[j-1]);//添加一条菜品信息
System.out.println(tables.get(j-1).getOrder().records.get(a).orderNum//输出订单信息
+" "+tables.get(j-1).getOrder().records.get(a).d.name+" "+
tables.get(j-1).getOrder().records.get(a).getPrice());
a++;
}
else System.out.println(dishInfo[1]+" does not exist");
}
else if(dishInfo.length == 5) {
int Num = Integer.parseInt(dishInfo[0]);//点菜序号
int lever = Integer.parseInt(dishInfo[2]);//口味度
int portion = Integer.parseInt(dishInfo[3]);//份量
int number = Integer.parseInt(dishInfo[4]);//份数
if(menu.searthDish(dishInfo[1]) != -1) {//该菜品存在
if((menu.checkType(dishInfo[1]).equals("川菜")
&&(lever<=5&&lever>=0))||
(menu.checkType(dishInfo[1]).equals("晋菜")
&&(lever<=4&&lever>=0))||
(menu.checkType(dishInfo[1]).equals("浙菜")
&&(lever<=3&&lever>=0))) {
tables.get(j-1).getOrder().addARecord(Num,
menu.dishs.get(menu.searthDish(dishInfo[1])),lever,portion,number,Specialdiscount[j-1]);//添加一条菜品信息
System.out.println(tables.get(j-1).getOrder().records.get(a).orderNum//输出订单信息
+" "+tables.get(j-1).getOrder().records.get(a).d.name+" "+
tables.get(j-1).getOrder().records.get(a).getPrice());
a++;
}
else {
if(menu.checkType(dishInfo[1]).equals("川菜")
&&!(lever<=5&&lever>=0)){
System.out.println("spicy num out of range :"+lever);
}
else if(menu.checkType(dishInfo[1]).equals("晋菜")
&&!(lever<=4&&lever>=0)) {
System.out.println("acidity num out of range :"+lever);
}
else if(menu.checkType(dishInfo[1]).equals("浙菜")
&&!(lever<=3&&lever>=0)) {
System.out.println("sweetness num out of range :"+lever);
}
}
}
else System.out.println(dishInfo[1]+" does not exist");
}
else {//代点菜
int subTableNum = Integer.parseInt(dishInfo[0]);
int Num = Integer.parseInt(dishInfo[1]);//点菜序号
int lever = Integer.parseInt(dishInfo[3]);//口味度
int portion = Integer.parseInt(dishInfo[4]);//份量
int number = Integer.parseInt(dishInfo[5]);//份数
int subOrder = 0;
for(s = 0;s < tables.size();s++) {
if(tables.get(s).tableNum.equals(dishInfo[0])) {
subOrder = s;
}
}
if(menu.searthDish(dishInfo[2]) != -1) {//该菜品存在
if((menu.checkType(dishInfo[2]).equals("川菜")
&&(lever<=5&&lever>=0))||
(menu.checkType(dishInfo[2]).equals("晋菜")
&&(lever<=4&&lever>=0))||
(menu.checkType(dishInfo[2]).equals("浙菜")
&&(lever<=3&&lever>=0))) {
tables.get(subOrder).getOrder().addARecord(Num,
menu.dishs.get(menu.searthDish(dishInfo[2])),lever,portion,number,Specialdiscount[j-1],1);//添加一条菜品信息
tables.get(j-1).getOrder().addARecord(1,Num,
menu.dishs.get(menu.searthDish(dishInfo[2])),lever,portion,number,Specialdiscount[j-1]);//添加一条菜品信息
System.out.println(Num+" table "+tables.get(j-1).tableNum+" pay for table "+subTableNum+" "+
tables.get(j-1).getOrder().records.get(a).getPrice());
a++;
}
else {
if(menu.checkType(dishInfo[1]).equals("川菜")
&&!(lever<=5&&lever>=0)){
System.out.println("spicy num out of range :"+lever);
}
else if(menu.checkType(dishInfo[1]).equals("晋菜")
&&!(lever<=4&&lever>=0)) {
System.out.println("acidity num out of range :"+lever);
}
else if(menu.checkType(dishInfo[1]).equals("浙菜")
&&!(lever<=3&&lever>=0)) {
System.out.println("sweetness num out of range :"+lever);
}
}
}
else System.out.println(dishInfo[2]+" does not exist");
// }
}
}
}
i++;
}
for(i = 0;i < tables.size();i++) {
if(flags[i] == 0) {
System.out.print("table "+tables.get(i).tableNum+": "+
tables.get(i).getOrder().getTotalPrice()+" "+
tables.get(i).getOrder().getDiscountTotalPrice());
if(tables.get(i).getOrder().getDishNum("川菜") != 0) {
average = (int)(tables.get(i).getOrder().getAverageLever("川菜")/
tables.get(i).getOrder().getDishNum("川菜") +0.5);
System.out.print(" 川菜 "+(int)tables.get(i).getOrder().getDishNum("川菜"));
if(average == 0)
System.out.print(" 不辣");
else if(average == 1)
System.out.print(" 微辣");
else if(average == 2)
System.out.print(" 稍辣");
else if(average == 3)
System.out.print(" 辣");
else if(average == 4)
System.out.print(" 很辣");
else if(average == 5)
System.out.print(" 爆辣");
}
if(tables.get(i).getOrder().getDishNum("晋菜") != 0) {
average = (int)(tables.get(i).getOrder().getAverageLever("晋菜")/
tables.get(i).getOrder().getDishNum("晋菜") +0.5);
System.out.print(" 晋菜 "+(int)tables.get(i).getOrder().getDishNum("晋菜"));
if(average == 0)
System.out.print(" 不酸");
else if(average == 1)
System.out.print(" 微酸");
else if(average == 2)
System.out.print(" 稍酸");
else if(average == 3)
System.out.print(" 酸");
else if(average == 4)
System.out.print(" 很酸");
}
if(tables.get(i).getOrder().getDishNum("浙菜") != 0) {
average = (int)(tables.get(i).getOrder().getAverageLever("浙菜")/
tables.get(i).getOrder().getDishNum("浙菜") +0.5);
System.out.print(" 浙菜 "+(int)tables.get(i).getOrder().getDishNum("浙菜"));
if(average == 0)
System.out.print(" 不甜");
else if(average == 1)
System.out.print(" 微甜");
else if(average == 2)
System.out.print(" 稍甜");
else if(average == 3)
System.out.print(" 甜");
}
System.out.print("\n");
}
}
for(i = 0;i < customers.size();i++) {
for(j = 0;j < tables.size();j++) {
if(customers.get(i).name.equals(tables.get(j).customerName)) {
customers.get(i).TotalPrice = customers.get(i).TotalPrice +
tables.get(j).getOrder().getDiscountTotalPrice();
}
}
}
for(i = 0;i < tables.size();i++){
for(j = 0;j < i;j++){
if(tables.get(i).customerName.equals(tables.get(j).customerName)) break;}
if(i==j) {
Customer customer = new Customer(tables.get(i).customerName,tables.get(i).number);
customers.add(customer);
}
}
String Cname = " ";
String Cnumber = " ";
int Tprice = 0;
for(i = 0;i < customers.size()-1;i++) {
for(j = 0;j < customers.size() - i - 1;j++) {
if(customers.get(j).name.compareToIgnoreCase(customers.get(j+1).name) > 0) {
Cname = customers.get(j).name;
customers.get(j).name = customers.get(j+1).name;
customers.get(j+1).name = Cname;
Cnumber = customers.get(j).number;
customers.get(j).number = customers.get(j+1).number;
customers.get(j+1).number = Cnumber;
Tprice = customers.get(j).TotalPrice;
customers.get(j).TotalPrice = customers.get(j+1).TotalPrice;
customers.get(j+1).TotalPrice = Tprice;
}
}
}
for(i = 0;i < customers.size();i++) {
if(flags[i] == 0) {
System.out.println(customers.get(i).name+" "+
customers.get(i).number+" "+customers.get(i).TotalPrice);
}
}
}
}
class Customer{
String name;
String number;
// Table[] table = new Table[100];
int TotalPrice = 0;
//public Customer() {
// }
public Customer(String name,String number) {
this.name = name;
this.number = number;
}
public static int weekday(int year, int month, int day){
Calendar cal = Calendar.getInstance();
cal.set(year,month,day);
return cal.get(Calendar.HOUR_OF_DAY);
}
}
class Table{
String tableNum;//桌子序号
String customerName;
String number;
String date;
String time;
Order order = new Order();
public Table(){
}
public Table(String tableNum,String customerName,String number,String date,String time){
this.tableNum = tableNum;
this.customerName = customerName;
this.number = number;
this.date = date;
this.time = time;
}
Order getOrder() {
return this.order;
}
public static int weekday(int year, int month, int day){
Calendar cal = Calendar.getInstance();
//月份要减一，在西方周日是一周的第1天（日期也需要减一）
cal.set(year,month-1,day-1);
return cal.get(Calendar.DAY_OF_WEEK);
}
}
class Dish{
String name;//菜名
String type = " ";//菜系
int unit_price = 0;//菜品单价
public Dish(){
}
public Dish(String name,int unit_price){
this.name = name;
this.unit_price = unit_price;
}
public Dish(String name,String type,int unit_price) {
this.name = name;
this.type = type;
this.unit_price = unit_price;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public String getType(){
return type;
}
public int getPrice(int portion){
int price = 0;
if(portion == 1){
price = (int)unit_price;
}
else if(portion == 2){
price = (int)(1.5*unit_price+0.5);
}
else if(portion == 3){
price = (int)(2*unit_price);
}
return price;
}
}
class Menu{
ArrayList<Dish> dishs = new ArrayList<>();
public Menu(){
}
int i = 0;
int searthDish(String dishName){
for(i = 0;i < dishs.size();i++)
if((dishs.get(i).name).equals(dishName)){
break;
}
if(i < dishs.size())
return i;
else return -1;
}
String checkType(String dishName) {
for(i = 0;i < dishs.size();i++)
if((dishs.get(i).name).equals(dishName)){
break;
}
return dishs.get(i).type;
}
void addDish(String dishName,int unit_price){
Dish dish = new Dish(dishName,unit_price);
dishs.add(dish);
}
void addSpecialDish(String dishName,String type,int unit_price) {
Dish dish = new Dish(dishName,type,unit_price);
dishs.add(dish);
}
}
class Record{
int orderNum;//序号
Dish d;//菜品
int lever = 0;//口味度
int portion;//份额
int num;//份数
double discount;
int flag = 0;
int sign = 0;
int sign2 = 0;
public Record(){
}
public Record(int orderNum,Dish d,int portion,int num,double discount){
this.orderNum = orderNum;
this.d = d;
this.portion = portion;
this.num = num;
this.discount = discount;
}
public Record(int orderNum,Dish d,int lever,int portion,int num,double discount){
this.orderNum = orderNum;
this.d = d;
this.lever = lever;
this.portion = portion;
this.num = num;
this.discount = discount;
}
public Record(int orderNum,Dish d,int lever,int portion,int num,double discount,int sign){
this.orderNum = orderNum;
this.d = d;
this.lever = lever;
this.portion = portion;
this.num = num;
this.discount = discount;
this.sign = sign;
}
public Record(int sign2,int orderNum,Dish d,int lever,int portion,int num,double discount){
this.sign2 = sign2;
this.orderNum = orderNum;
this.d = d;
this.lever = lever;
this.portion = portion;
this.num = num;
this.discount = discount;
}
int getPrice(){//计价，计算本条记录的价格
return d.getPrice(portion)*num;
}
int getDiscountPrice() {
return (int)(d.getPrice(portion)*num*discount+0.5);
}
public void showRecord() {
System.out.println(orderNum+" "+d.name+" "+getPrice());
}
int getLever() {
return num * lever;
}
}
class Order {
int totalprice = 0;
int total;
int Lever = 0;
double dishNum = 0;
int i = 0,k = 0,a= 0,b = 0;
ArrayList<Record> records = new ArrayList<>();
int getTotalPrice(){//计算订单的总价
totalprice = 0;
for(i = 0;i < records.size();i++) {
if(records.get(i).sign == 0) {
a = records.get(i).getPrice();
totalprice += a;
}
}
return totalprice;
}
int getDiscountTotalPrice() {
totalprice = 0;
for(i = 0;i < records.size();i++) {
if(records.get(i).sign == 0) {
a = records.get(i).getDiscountPrice();
totalprice += a;
}
}
return totalprice;
}
int getAverageLever(String type) {//输出指定菜系的口味值
Lever = 0;
if(type.equals("川菜"))
for(i = 0;i < records.size();i++) {
if(records.get(i).sign2 == 0) {
if(records.get(i).d.type.equals(type))
Lever = Lever + records.get(i).getLever();
}
}
else if(type.equals("晋菜")) {
for(i = 0;i < records.size();i++) {
if(records.get(i).sign2 == 0) {
if(records.get(i).d.type.equals(type))
Lever = Lever + records.get(i).getLever();
}
}
}
else if(type.equals("浙菜")) {
for(i = 0;i < records.size();i++) {
if(records.get(i).sign2 == 0) {
if(records.get(i).d.type.equals(type))
Lever = Lever + records.get(i).getLever();
}
}
}
return Lever;
}
double getDishNum(String type) {//输出指定菜系的总份数
dishNum = 0;
if(type.equals("川菜")) {
for(i = 0;i < records.size();i++) {
if(records.get(i).sign2 == 0) {
if(records.get(i).d.type.equals(type))
dishNum = dishNum + records.get(i).num;
}
}
}
if(type.equals("晋菜")) {
for(i = 0;i < records.size();i++) {
if(records.get(i).sign2 == 0) {
if(records.get(i).d.type.equals(type))
dishNum = dishNum + records.get(i).num;
}
}
}
if(type.equals("浙菜")) {
for(i = 0;i < records.size();i++) {
if(records.get(i).sign2 == 0) {
if(records.get(i).d.type.equals(type))
dishNum = dishNum + records.get(i).num;
}
}
}
return dishNum;
}
void addARecord(int orderNum,Dish d,int portion,int num,double discount){
Record record = new Record(orderNum,d,portion,num,discount);
records.add(record);
}//添加一条菜品信息到订单中。
void addARecord(int orderNum,Dish d,int lever,int portion,int num,double discount){
Record record = new Record(orderNum,d,lever,portion,num,discount);
records.add(record);
}//添加一条菜品信息到订单中。
void addARecord(int orderNum,Dish d,int lever,int portion,int num,double discount,int sign){
Record record = new Record(orderNum,d,lever,portion,num,discount,sign);
records.add(record);
}//添加一条菜品信息到订单中。
void addARecord(int sign2,int orderNum,Dish d,int lever,int portion,int num,double discount){
Record record = new Record(sign2,orderNum,d,lever,portion,num,discount);
records.add(record);
}//添加一条菜品信息到订单中。
void delARecordByOrderNum(int orderNum){
records.remove(orderNum-1);
}//根据序号删除一条记录
boolean findRecordByNum(int orderNum){//根据序号查找一条记录
for(i = 0;i < records.size();i++)
if(records.get(i).orderNum == orderNum){
break;
}
if(i == records.size()) {
return false;
}
else return true;
}
}
View Code
类图如下：
分析：本次题目是菜单系列最后一道，难度比上一次的题目低，但是也很复杂。由于题目中可能出现的情况有很多种，所以使用了大量的if-else语句，使得程序结构变得十分冗长复杂。自己也看的眼花缭乱。
期中考试
测验1-圆类设计
创建一个圆形类（Circle），私有属性为圆的半径，从控制台输入圆的半径，输出圆的面积
输入格式:
输入圆的半径，取值范围为(0,+∞)，输入数据非法，则程序输出Wrong Format，注意：只考虑从控制台输入数值的情况
输出格式:
输出圆的面积（保留两位小数，可以使用String.format(“%.2f”,输出数值）控制精度）
代码如下：
import java.util.Scanner;
class Circle{
private double radius;
public Circle(double radius){
this.radius=radius;
}
public void getArea(){
double area=0;
if(radius<=0)
System.out.println("Wrong Format");
else{
area=Math.PI*radius*radius;
System.out.println(String.format("%.2f",area) );
}
}
}
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double radius=input.nextDouble();
Circle circle=new Circle(radius);
circle.getArea();
}
}
测验2-类结构设计
设计一个矩形类，其属性由矩形左上角坐标点（x1，y1）及右下角坐标点（x2，y2）组成，其中，坐标点属性包括该坐标点的X轴及Y轴的坐标值（实型数），求得该矩形的面积。类设计如下图：
输入格式:
分别输入两个坐标点的坐标值x1，y1，x2，y2。
输出格式:
输出该矩形的面积值（保留两位小数）。
代码如下：
import java.util.Scanner;
class Rectangle{
private double x1,x2,y1,y2;
public Rectangle(double x1,double x2,double y1,double y2){
this.x1=x1;
this.x2=x2;
this.y1=y1;
this.y2=y2;
}
public void getArea(){
//double area=0;
double area=Math.abs((x2-x1)*(y2-y1) );
//return area;
System.out.println(String.format("%.2f",area ) );
}
}
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double x1=input.nextDouble();
double x2=input.nextDouble();
double y1=input.nextDouble();
double y2=input.nextDouble();
//double area=0;
Rectangle rec=new Rectangle(x1,x2,y1,y2);
rec.getArea();
}
}
View Code
分析：题目是简单的，但是我写代码不熟练，导致时间没有把握好，第四题都没时间了。写代码能力还是很弱，仍需努力。都是泪啊。
测验3-继承与多态
太丢脸了，代码就不复制了。简单说一下对这个题目的分析吧。
分析：代码中使用了抽象类Shape，并通过Circle和Rectangle类进行继承。难点在于理解抽象类的作用以及如何正确地实现子类对抽象方法的覆写。异常处理：代码中对输入进行了一些合法性检查，比如半径和坐标的合法性，需要确保对异常情况的处理是正确的。需要理解多态的概念以及方法的动态绑定机制。Point类的设计也是一个难点，需要理解如何设计合适的类来表示坐标点，并进行正确的信息封装和访问控制。
三.踩坑心得
最麻烦的就是菜单计价程序-4，题目本身并不需要用什么新方法，但是题目要求的东西非常多，错误类型多种多样，测试点有很多，开始写代码前要把各种错误情况和测试点的提示都看一遍。复杂的程序一定要先把结构和功能想好再动手。其次还有类的设计，要提前想好哪个方法应该放在哪个类里，用什么关系实现，boolean的返回值要反复斟酌，一开始true和false的出错，会大大提升后期修改的难度。经常出现的错误是输入验证存在问题。一碰到这个问题就很烦，要花很多时间去查对我来说。
四.改进建议
学习自己不懂的地方，以及多使用不同类对各功能进行区分，对之后修改代码更便利。对于不懂的知识点，一定要及时去查资料把它理解透彻。有能力的可以画类图，而且老师上课讲了几种设计方法，对于写菜单题目是比较好用的。其次代码结构不清晰，结构混乱，不易维护和理解。 建议将代码拆分成更小的函数或类，每个函数/类只负责一项具体的功能，提高可读性和可维护性。
五.总结
菜单系列的题目好痛苦，加上畏难心理后期基本没有掌握到什么，反而在前期查询资料学会了使用集合类（如ArrayList和HashMap）来存储和管理数据，通过学习他人的代码，结合自己的理解，将代码进行修改，过程是很艰难的但是看到测试点通过的时候是真的开心。对于接口这部分的知识，尚且不了解，在课后要多查资料去学习，掌握越多新知识，写代码也会更加方便。在之后的学习中，努力掌握其他知识，改进类间关系，增强代码的可读性，努力减小耦合度和圈复杂度。课本上的知识需要我们自己去消化，还是有很多地方需要我们仔细思考的。
标签：String,get,int,messageList,BLOG,records,add From： https://www.cnblogs.com/flowerof/p/17842244.html