一、前言：
我通过学习面向对象程序设计这门课程，深入掌握了Java语言的知识。截至目前，三个PTA作业，这些作业主要涉及Java的结构、类的运用、以及一些方法的使用，其中类的应用是重点。这三次作业的难度逐渐加大，同时作业量也在逐步增加。最令我印象深刻的是点菜，每一次都让我心如焦土，无可奈何，耗费大量时间完成，但我也从其中获得锻炼与提升。
二、设计与分析：
（1）第一次题目集
第一次题目集的9个题目难度不是很大，主要是为了帮助学生更好的转变向java语言的学习，巩固学生们对java最基础的知识。其中一题印象深刻：
7-6 学号识别 分数 10 作者 蔡轲 单位 南昌航空大学
学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号
输入格式:
8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入
输出格式:
学号每一项的完整说明。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
注意：如非法输入，输出“Wrong Format"
输入样例:
在这里给出一组输入。例如：
18011103
输出样例:
在这里给出相应的输出。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
输入样例1:
在这里给出一组输入。例如：
18013
输出样例1:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
String a;
String year,college,clas,num;
Scanner in = new Scanner(System.in);
a = in.next();
if(8!=a.length()) {
System.out.print("Wrong Format");
return;
}
year = a.substring(0,2);
college = a.substring(2,4);
clas = a.substring(4,6);
num = a.substring(6,8);
if(college.equalsIgnoreCase("01")) {
college = "材料学院";
}else if(college.equalsIgnoreCase("02")) {
college = "机械学院";
}else if(college.equalsIgnoreCase("03")) {
college = "外语学院";
}else if(college.equalsIgnoreCase("20")) {
college = "软件学院";
}else {
System.out.print("Wrong Format");
return;
}
System.out.print("入学年份：20"+year+"年\n"
+ "学院："+college+"\n"
+ "班级："+clas+"\n"
+ "学号："+num);
}
}
分析：这个题目之所以令我印象深刻，主要是与之前的c语言不同的思维方式与技巧。这个题目采用了一个subtring()的方法，做到了格式化，标准化的输入检查，也简便了代码。
（2）第二次题目集
第二次题目集难度与复杂度明显升高，尤其是点菜计价程序，花费了大量时间，分析如下；
7-1 菜单计价程序-1 分数 30 作者 蔡轲 单位 南昌航空大学某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist
48
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
Menu menu=new Menu();
Dish d=new Dish("西红柿炒蛋",15);
menu.add(d);
d=new Dish("清炒土豆丝",12);
menu.add(d);
d=new Dish("麻婆豆腐",12);
menu.add(d);
d=new Dish("油淋生菜",9);
menu.add(d);
String str=in.next();
//portion=in.nextInt();
Order order=new Order(menu);
while(str.equals("end")==false)
{
int portion=in.nextInt();
if(order.addARecord(str,portion)==null)
{
System.out.println(str+" does not exist");
}
str=in.next();
//portion=in.nextInt();
}
System.out.println(order.getTotalPrice());
return;
}
}
class Dish{
String name;
int unit_price;
Dish(String name,int unit_price){
this.name=name;
this.unit_price=unit_price;
}
int getPrice(int portion){ //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，
int price=0;
if(portion==1)
price=unit_price;
if(portion==2)
price=Math.round(unit_price*1.5f);
if(portion==3)
price=unit_price*2;
return price;
}
}
class Menu{
ArrayList<Dish> Dishmenu=new ArrayList<>();
void add(Dish dish){
Dishmenu.add(dish);
}
Dish searthDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象。
for(int i=0;i<Dishmenu.size();i++)
{
if(Dishmenu.get(i).name.equals(dishName))
return Dishmenu.get(i);
}
return null;
}
}
class Record{
Dish d;
int portion;
Record(Dish d,int portion){
this.d=d;
this.portion=portion;
}
int getPrice()//计价，计算本条记录的价格
{
int price=d.getPrice(portion);
return price;
}
}
class Order{
ArrayList<Record> records=new ArrayList<>();
Menu menu;
Order(Menu menu){
this.menu=menu;
}
Record addARecord(String dishName,int portion)//添加一条菜品信息到订单中。
{
Dish dish=menu.searthDish(dishName);
Record record=null;
if(dish!=null)
{
record=new Record(dish,portion);
records.add(record);
}
return record;
}
int getTotalPrice()//计算订单的总价
{
int total=0;
for(int i=0;i<records.size();i++)
{
total+=records.get(i).getPrice();
}
return total;
}
}
分析：由于我个人的能力问题，最初使用了面向过程的方法（博客中展示的是后来改进的面向对象的代码）。在从面向过程到面向对象的转变过程中，主要是通过类的运用，将代码分成了Dish{}、Menu{}、Record{}和Order{}等类。这可以被理解为拆分的一个过程，但实际上，在这道题中，一些主要算法的差异并不大，主要是判断输入选择和使用equals()方法。在完成这道题后，我对类的使用更加熟悉，包括学习了如何使用equals()方法及其用法。
7-2 菜单计价程序-2 分数 40 作者 蔡轲 单位 南昌航空大学设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"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”
最后输出订单上所有菜品的总价（整数数值），
本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
63
输入样例1:
订单中包含删除记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例1:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
27
输入样例2:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
end
输出样例2:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
63
输入样例3:
订单中包含删除信息以及不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 delete
7 delete
end
输出样例3:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
27
输入样例4:
订单中包含删除信息以及不存在的菜品记录。例如：
麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
end
输出样例4:
在这里给出相应的输出。例如：
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
63
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
Menu menu=new Menu();
Dish d=new Dish("西红柿炒蛋",15);
menu.add(d);
d=new Dish("清炒土豆丝",12);
menu.add(d);
d=new Dish("麻婆豆腐",12);
menu.add(d);
d=new Dish("油淋生菜",9);
menu.add(d);
String str=in.next();
//portion=in.nextInt();
Order order=new Order(menu);
while(str.equals("end")==false)
{
int portion=in.nextInt();
if(order.addARecord(str,portion)==null)
{
System.out.println(str+" does not exist");
}
str=in.next();
//portion=in.nextInt();
}
System.out.println(order.getTotalPrice());
return;
}
}
class Dish{
String name;
int unit_price;
Dish(String name,int unit_price){
this.name=name;
this.unit_price=unit_price;
}
int getPrice(int portion){ //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，
int price=0;
if(portion==1)
price=unit_price;
if(portion==2)
price=Math.round(unit_price*1.5f);
if(portion==3)
price=unit_price*2;
return price;
}
}
class Menu{
ArrayList<Dish> Dishmenu=new ArrayList<>();
void add(Dish dish){
Dishmenu.add(dish);
}
Dish searthDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象。
for(int i=0;i<Dishmenu.size();i++)
{
if(Dishmenu.get(i).name.equals(dishName))
return Dishmenu.get(i);
}
return null;
}
}
class Record{
Dish d;
int portion;
Record(Dish d,int portion){
this.d=d;
this.portion=portion;
}
int getPrice()//计价，计算本条记录的价格
{
int price=d.getPrice(portion);
return price;
}
}
class Order{
ArrayList<Record> records=new ArrayList<>();
Menu menu;
Order(Menu menu){
this.menu=menu;
}
Record addARecord(String dishName,int portion)//添加一条菜品信息到订单中。
{
Dish dish=menu.searthDish(dishName);
Record record=null;
if(dish!=null)
{
record=new Record(dish,portion);
records.add(record);
}
return record;
}
int getTotalPrice()//计算订单的总价
{
int total=0;
for(int i=0;i<records.size();i++)
{
total+=records.get(i).getPrice();
}
return total;
}
}
分析：在开始时，我直接提交了这道题，但是只过了一部分测试点——菜单那个一分。在我的提交中，没有实现删除功能，这也是类的一种使用方式。但是，为了进一步提高我的编程能力，我需要学习使用像split()、Integer.parseInt()等方法。例如，Integer.parseInt()是Java中的一个方法，用于将字符串转换为整数。如果字符串str无法转换为整数，则会抛出NumberFormatException异常。
在使用@Override时，需要注意以下几点：
-
@Override注解只能用于重写父类方法或实现接口方法，如果使用在其他方法上会报错。
-
方法名、方法参数类型和个数、返回值类型必须与父类方法或接口方法完全一致。
-
访问修饰符不能更低，不能从protected改为public，也不能从public改为private。
-
父类方法或接口方法必须在子类中存在，否则会报错。
-
如果重写的方法抛出了异常，不能比父类方法声明的异常更宽泛。
-
如果重写的方法是final的，会报错。
-
如果重写的方法是static的，会被视为一个新方法，而不是重写父类方法。
-
如果是重写Object类的方法，如toString()、equals()、hashCode()等，建议加上@Override注解。
总之，使用@Override注解时需要仔细检查方法的签名是否符合要求，否则会出现编译错误。
（3）第三次题目集
7-1 菜单计价程序-3 分数 30 作者 蔡轲 单位 南昌航空大学设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"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+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 12/2/3
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 38
输入样例1:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 17/0/0
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例1:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 22
输入样例2:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 16/59/59
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例2:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1 out of opening hours
输入样例3:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2022/12/5 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
7 delete
end
输出样例3:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
table 2:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
table 1 out of opening hours
table 2: 63
输入样例4:
在这里给出一组输入。例如：
麻婆豆腐 12
油淋生菜 9
table 1 2022/12/3 19/5/12
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 4 麻婆豆腐 1 1
7 delete
end
输出样例4:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
table 2:
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
4 table 2 pay for table 1 12
delete error;
table 1: 63
table 2: 75
class Dish {
String name;//菜品名称
int unit_price; //单价
//int num;
int getPrice(int portion) {
int peic = 0;
if (portion == 1) {
peic = unit_price ;
} else if (portion == 2) {
peic = Math.round((float) (unit_price * 1.5)) ;
} else if (portion == 3) {
peic = (unit_price * 2) ;
}
return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
}
class Menu {
Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息
int count = 0;
Dish searthDish(String dishName){
Dish temd = null;
for(int i=count-1;i>=0;i--){
if(dishName.equals(dishs[i].name)){
temd = dishs[i];
break;
}
}
if(temd==null){
System.out.println(dishName+" does not exist");
}
return temd;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price){
Dish dh = new Dish();
dh.name = dishName;
dh.unit_price = unit_price;
count++;
return dh;
}//添加一道菜品信息
}
class Record {
int orderNum;//序号\
//int AntherOrderNum;
Dish d = new Dish();//菜品\
int num = 0;
int portion;//份额（1/2/3代表小/中/大份）\
//int exist = 1;
int getPrice(){
return d.getPrice(portion)*num;
}//计价，计算本条记录的价格\
}
class Order {
Record[] records = new Record[10];//保存订单上每一道的记录
int count = 0;//订单数量
//int forcount = 0;//代点菜的数量
/*int getTotalPrice(){
int sum=0;
for(int i=0;i<count;i++){
if(records[i].exist==0)
continue;
sum=sum+records[i].getPrice();
}
return sum;
}//计算订单的总价*/
void addARecord(int orderNum,String dishName,int portion,int num){
records[count] = new Record();
records[count].d.name = dishName;
records[count].orderNum = orderNum;
records[count].portion = portion;
records[count].num = num;
count++;
}//添加一条菜品信息到订单中。
/*Record TakeOdfor(int AnotherNUm,int orderNum,String dishName,int portion,int num){
Record rd2 = new Record();
rd2.d.name = dishName;
rd2.orderNum = orderNum;
rd2.portion = portion;
rd2.d.num = num;
rd2.AntherOrderNum = AnotherNUm;
//forcount++;
return rd2;
}*/
int delARecordByOrderNum(int orderNum){
if(orderNum>count||orderNum<=0){
System.out.println("delete error;");
return 0;
}else {
return records[orderNum - 1].getPrice();
}
}//根据序号删除一条记录
}
class Table {
int tableNum;
String tableDtime;
int year,month,day,week,hh,mm,ss;
int sum = 0;//一桌价格 ；
// boolean f = true;
Order odt = new Order();
//Order odre = new Order();
float discnt = -1;
void Gettottalprice(){
if(discnt>0){
sum = Math.round(sum*discnt);
System.out.println("table " + tableNum + ": " + sum);
}else {
System.out.println("table " + tableNum + " out of opening hours");
}
}
void AheadProcess(String tableDtime){
this.tableDtime = tableDtime;
processTime();
discount();
//CheckAtime();
}
void processTime(){//处理时间
String[] temp = tableDtime.split(" ");
tableNum = Integer.parseInt(temp[1]);
String[] temp1 = temp[2].split("/");
String[] temp2 = temp[3].split("/");
year = Integer.parseInt(temp1[0]);
month = Integer.parseInt(temp1[1]);
day = Integer.parseInt(temp1[2]);
Calendar c = Calendar.getInstance();
c.set(year, (month-1), day);
week = c.get(Calendar.DAY_OF_WEEK);
if(week==1)
week = 7;
else
week--;
hh = Integer.parseInt(temp2[0]);
mm = Integer.parseInt(temp2[1]);
ss = Integer.parseInt(temp2[2]);
}
//void CheckAtime(){
// f= !(discnt < 0);
// }
void discount(){
if(week>=1&&week<=5)
{
if(hh>=17&&hh<20)
discnt=0.8F;
else if(hh==20&&mm<30)
discnt=0.8F;
else if(hh==20&&mm==30&&ss==0)
discnt=0.8F;
else if(hh>=11&&hh<=13||hh==10&&mm>=30)
discnt=0.6F;
else if(hh==14&&mm<30)
discnt=0.6F;
else if(hh==14&&mm==30&&ss==0)
discnt=0.6F;
}
else
{
if(hh>=10&&hh<=20)
discnt= 1.0F;
else if(hh==9&&mm>=30)
discnt= 1.0F;
else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
discnt= 1.0F;
}
}
}
import java.util.Calendar;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Menu mu = new Menu();
Table[] tablemes = new Table[10];
int j = 0;//菜单数
int l = 0;//订单数
int k = 0;//代点菜数
Dish tt;
//int sum = 0;
int cntTable = 0;//桌号
int count;
String[] temp;
int a1,a2,a3,a4,a5;
while (true) {
String st = sc.nextLine();
temp = st.split(" ");
if(st.equals("end"))
break;
count = temp.length;
if (count == 2) {//一个空格
//String[] temp1 = st.split(" ");
if (temp[1].equals("delete")) {//第二个为delete
a1 = Integer.parseInt(temp[0]);
int c = tablemes[cntTable].odt.delARecordByOrderNum(a1);
tablemes[cntTable].sum-=c;
} else {//菜单添加
a2 = Integer.parseInt(temp[1]);
mu.dishs[j] = mu.addDish(temp[0], a2);
j++;
}
//continue;
}
else if (count == 4) {//三个空格
//String[] temp2 = st.split(" ");
if (temp[0].equals("table")) {//桌号
cntTable++;//跳过0;
l = 0;
tablemes[cntTable] = new Table();
//tablemes[cntTable].tableDtime = st;
tablemes[cntTable].AheadProcess(st);
System.out.println("table " + cntTable + ": ");
} else {//增加订单的情况；
a3 =Integer.parseInt(temp[0]);
a4 = Integer.parseInt(temp[2]);
a5=Integer.parseInt(temp[3]);
tablemes[cntTable].odt.addARecord(a3, temp[1],a4 , a5);
tt = mu.searthDish(temp[1]);
if (tt != null) {
tablemes[cntTable].odt.records[l].d = tt;
int a = tablemes[cntTable].odt.records[l].getPrice();
System.out.println(tablemes[cntTable].odt.records[l].orderNum + " " + tt.name + " " +a );
tablemes[cntTable].sum +=a;
}
l++;
}
//continue;
}
else if (count == 5) {//代点菜
//String[] temp3 = st.split(" ");
a1 = Integer.parseInt(temp[1]);
a2 = Integer.parseInt(temp[3]);
a3 = Integer.parseInt(temp[4]);
tablemes[cntTable].odt.addARecord( a1, temp[2], a2, a3);
tt = mu.searthDish(temp[2]);
if (tt != null) {
tablemes[cntTable].odt.records[l].d.unit_price = tt.unit_price;
int b = tablemes[cntTable].odt.records[l].getPrice();
System.out.println(temp[1] + " table " + tablemes[cntTable].tableNum + " pay for table " + temp[0] + " " + b);
tablemes[cntTable].sum += b;
}
l++;
}
//st = sc.nextLine();
}
for (int i = 1; i < cntTable + 1; i++) {
tablemes[i].Gettottalprice();
}
}
}
分析：这次点菜真没有搞懂，代码是借鉴的。
三：踩坑心得
我遇到过不少Java题目踩坑的经历。下面是我总结出来的一些心得和经验，希望对大家有所帮助：
1. 注意类名的大小写：在Java中，类名的第一个字母通常是大写的，而方法和变量名的第一个字母通常是小写的，如果不注意大小写会导致编译错误或者运行时错误。
2. 了解Java的数据类型：Java的数据类型有八种基本类型，分别是byte、short、int、long、float、double、boolean和char。在进行变量声明和赋值时，需要注意数据类型的匹配和转换，否则会出现类型不匹配的错误。
3. 掌握Java基本语法：Java有自己的语法规则，比如括号、分号等等。如果不了解这些规则，会导致编译错误或者运行时错误。
4. 异常处理：Java中的异常处理是非常重要的，需要在代码中合理使用try-catch语句，捕获并处理异常，否则会导致程序运行出错或者崩溃。
5. 熟练掌握Java的面向对象编程思想：Java是一种面向对象编程的语言，需要熟练掌握面向对象编程的思想和相关知识，比如封装、继承和多态等。
6. 善于使用Java的API：Java有非常丰富的类库和API，可以大大提高编程的效率和质量。需要善于使用Java的API，尤其是Java 8及以上版本中新增的Stream API等。
7. 尽量避免硬编码：在编写Java程序时，应该尽量避免硬编码，即直接将数据或者常量写入代码中。可以将这些数据或者常量定义为变量或者常量，以便于修改和维护。
四：主要困难以及改进建议
学习Java的主要困难和改进建议如下：
主要困难：
1. 语法复杂：Java是一种高级编程语言，语法和概念比较复杂，初学者可能会感到难以理解。
2. 对面向对象编程的理解不够深入：Java是一种面向对象的语言，初学者可能对面向对象的思想和概念不够深入理解，导致编写代码时不符合面向对象的要求。
3. 框架过多：Java有很多框架，比如Spring、Struts、Hibernate等，初学者可能会觉得迷茫，不知道哪种框架适合自己的项目。
改进建议：
1. 重视基础知识的学习：Java编程语言本身比较复杂，想要学好Java，需要抓好基础知识的学习，如语法、变量类型、面向对象编程等基础知识。
2. 练习编写代码：编写代码是学好Java的最好途径，可以选择一些经典的编程练习来提高编程能力，如LeetCode、牛客网、GitHub等。
3. 学会使用框架：Java的框架非常多，但是只有掌握了一些常用的框架才能更好地进行Java开发。建议初学者先学习Spring、Hibernate、Struts等必须掌握的框架。
4. 寻找好的学习途径：学习Java需要花费大量的时间和精力。可以选择一些在线课程、公开课或出版物等进行学习，或者加入Java相关的社区，多与其他Java爱好者交流。
五：总结
作为一个初学者，Java是一门非常受欢迎的编程语言，这里是我对Java初期学习的总结：
-
学习语法：首先，需要掌握Java的基础语法，包括变量、数据类型、运算符、控制流等等。可以通过阅读教材、观看视频教程和参考代码来学习。
-
练习编码：学习语法后，需要在实践中进行练习。尝试编写一些简单的程序，例如计算器或猜数字游戏等等。这样可以加深对语法的理解，并提高编程技能。
-
使用IDE：Java有许多IDE（集成开发环境），例如Eclipse、NetBeans和IntelliJ IDEA等等。使用IDE可以大大提高编写代码的效率，同时还可以轻松地调试代码。
-
学习面向对象编程：Java是一种面向对象的编程语言，因此必须掌握面向对象编程（OOP）的概念，例如类、对象、继承和多态性等等。这对于编写复杂的程序非常重要。
-
了解Java API：Java具有广泛的API（应用程序接口），使得编写程序变得更加容易。可以在编写程序时查找文档，以便快速了解如何使用API。
-
学习异常处理：Java中存在许多异常，例如除以零、数组越界和空指针等等。因此需要学习如何捕获和处理异常，以确保程序的稳定性和可靠性。
-
阅读其他人的代码：阅读其他人编写的Java代码可以帮助初学者更好地理解语法和实践的应用。从其他人的代码中学习并借鉴他们的思路和技巧也是非常有益的。
总之，Java是一门非常强大和广泛使用的编程语言。初学者需要耐心学习，并通过不断练习和完善来提高自己的技能。
标签：总结性,Java,记录,int,PTA,Blog,菜品,Dish,麻婆豆腐 From： https://www.cnblogs.com/tanwudi/p/17426316.html