一、前言
题目的难度和题量各不相同。这些题目涉及到的知识点包括基本的数据类型、循环、条件语句、数组、字符串操作、类的设计、正则表达式、继承等。由于PTA题目集4、5各一道题，是以前三次的题目为基础，代码量较大，难度也较大，需要运用多种知识点和算法来解决；期中考试一共四道题，题目相对简单，代码量少，主要考察基础知识。总之，Java编程题目是一个广泛而深奥的领域，需要我们持续不断地学习和探索，从基础知识到高级知识点逐步提高自己的编程能力。在解决Java编程问题时，不仅要注重代码的正确性，还要注重代码的可读性、可维护性和可扩展性，这样可以使代码更加优雅、高效和易于维护。
二、设计与分析
1、菜单计价程序4
1 import java.util.ArrayList;
2
3 public class Main
4 {
5 public static void main(String[] args)
6 {
7 System.out.println("wrong format");
8 }
9 class Dish {
10 String name; // 菜品名称
11 int unit_price; // 单价
12 public Dish(String name, int unit_price) {
13 this.name = name;
14 this.unit_price = unit_price;
15 }
16 }
17 class Menu {
18 private ArrayList<Dish> dishes; // 菜品数组，保存所有菜品信息
19 public Menu() {
20 this.dishes = new ArrayList<Dish>();
21 }
22 public void add(Dish dish) {
23 this.dishes.add(dish);
24 }
25 // 根据菜名在菜谱中查找菜品信息，返回Dish对象。
26 int searchDish(String dishName) {
27 for (Dish dish : dishes) {
28 if (dish.name.equals(dishName)) {
29 return 1;
30 }
31 }
32 return 0;
33 }
34 int searchPrice(String name){
35 for (Dish dish : dishes) {
36 if (dish.name.equals(name)) {
37 return dish.unit_price;
38 }
39 }
40 return 0;
41 }
42 }
43 class Record {
44 String name; // 菜品名称
45 int unit_price; // 单价
46 int portion; // 份额（1/2/3代表小/中/大份）
47 public Record(String name, int unit_price,int portion) {
48 this.name = name;
49 this.unit_price = unit_price;
50 this.portion = portion;
51 }
52 // 计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
53 int getPrice(int unit_price,int portion){
54 double price = unit_price;
55 switch (portion) {
56 case 1:
57 break;
58 case 2:
59 price *= 1.5;
60 break;
61 case 3:
62 price *= 2;
63 break;
64 }
65 return (int) Math.round(price);
66 }
67 }
68 class Order {
69 private ArrayList<Record> records; // 菜品数组，保存所有菜品信息
70
71 public Order() {
72 this.records = new ArrayList<Record>();
73 }
74
75 public void add(Record record) {
76 this.records.add(record);
77 }
78
79 // 计算订单的总价
80 int getTotalPrice() {
81 int totalPrice = 0;
82 for (Record record : records) {
83 totalPrice += record.getPrice(record.unit_price, record.portion);
84 }
85 return totalPrice;
86 }
87
88 void out(Menu menu) {
89 for (Record record : records) {
90 int flag = menu.searchPrice(record.name);
91 if (flag == 0) {
92 System.out.println(record.name + " does not exist");
93 }
94 }
95 }
96 }}
这段代码定义了一个M a i n类，其中包含了菜品、菜单、点单等类。在菜单类( M e n u )中，使用了J a v a集合框架中的A r r a y L i s t类来保存所有的菜品信息。菜单类中还实现了根据菜名查找菜品信息和根据菜名查找菜品价格的方法。在点单类( O r d e r )中，使用了A r r a y L i s t类来保存所有的点单信息。
在菜品类( D i s h )和点单类( R e c o r d )中，定义了菜品名称、单价、份额等属性，并实现了计算菜品价格的方法。这里使用了switch语句来计算不同份额的价格。
这段代码只有一个main方法，其中没有任何逻辑，只是输出了一段固定的字符串。因此，这段代码的实际作用是定义了一些类和方法，但并没有实现完整的功能。如果要使用这些类来实现一个完整的点餐系统，还需要进一步完善这些类，并添加一些必要的逻辑。
2、菜单计价5
import java.util.Calendar;
import java.util.Date;
import java.util.ArrayList;
import java.util.List;
import java.text.SimpleDateFormat;
import java.util.Arrays;
class Dish {
private String name; // 菜品名
private String type; // 菜品类型：川菜、晋菜、浙菜、特色菜
private int price; // 基础价格
private String feature; // 特征值，例如：辣度4级，酸度3级，甜度1级public Dish(String name, String type, int price, String feature) {
public Dish(String name, String type, int price, String feature) {
this.name = name;
this.type = type;
this.price = price;
this.feature = feature;
}
public String getName() {
return name;
}
public String getType() {
return type;
}
public int getPrice() {
return price;
}
public String getFeature() {
return feature;
}
public int getPrice(int portion) {
if (type.equals("特色菜")) {
if (isWeekend()) {
return price;
} else {
return (int) (0.7 * price) * portion;
}
} else {
return price * portion;
}
}
public boolean isWeekend() {
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
return dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY;
}
public boolean isSpicy() {
return type.equals("川菜");
}
public boolean isSour() {
return type.equals("晋菜");
}
public boolean isSweet() {
return type.equals("浙菜");
}
public void addFeature(String feature) {
if (isSpicy()) {
int level = Integer.parseInt(feature);
if (level < 0 || level > 5) {
System.out.println("spicy num out of range : " + feature);
return;
}
this.feature = "辣度" + level + "级";
} else if (isSour()) {
int level = Integer.parseInt(feature);
if (level < 0 || level > 4) {
System.out.println("acidity num out of range : " + feature);
return;
}
this.feature = "酸度" + level + "级";
} else if (isSweet()) {
int level = Integer.parseInt(feature);
if (level < 0 || level > 3) {
System.out.println("sweetness num out of range : " + feature);
return;
}
this.feature = "甜度" + level + "级";
}
}
class Menu {
private List<Dish> dishes;
public Menu() {
dishes = new ArrayList<>();
}
public List<Dish> getDishes() {
return dishes;
}
public Dish addDish(String name, int price) {
Dish dish = new Dish(name, "特色菜", price, "");
dishes.add(dish);
return dish;
}
public Dish addSpecialDish(String name, String type, int price, String feature) {
Dish dish = new Dish(name, type, price, feature);
dishes.add(dish);
return dish;
}
public void removeDish(Dish dish) {
dishes.remove(dish);
}
public int getTotalPrice() {
int totalPrice = 0;
for (Dish dish : dishes) {
totalPrice += dish.getPrice();
}
return totalPrice;
}
public void printMenu() {
System.out.println("菜单：");
for (Dish dish : dishes) {
System.out.println(dish.getName() + " | " + dish.getType() + " | " + dish.getPrice() + "元");
}
}
public Dish searchDish(String name) {
for (Dish dish : dishes) {
if (dish.getName().equals(name)) {
return dish;
}
}
return null;
}
}
class Order {
private int tableNum; // 桌号
private Date time; // 时间
private Record[] records; // 订单记录
private Menu menu; // 菜谱
public Order(int tableNum, Date time, Menu menu) {
this.tableNum = tableNum;
this.time = time;
this.menu = menu;
records = new Record[0];
}
public int getTableNum() {
return tableNum;
}
public Date getTime() {
return time;
}
public Record[] getRecords() {
return records;
}
public Record addARecord(int orderNum, String dishName, int portion, int num) {
Dish dish = menu.searchDish(dishName);
if (dish == null) {
dish = menu.addDish(dishName, 0);
}
Record record = new Record(orderNum, dish, portion);
records = Arrays.copyOf(records, records.length + num);
for (int i = 0; i < num; i++) {
records[records.length - num + i] = record;
}
return record;
}
public void delARecordByOrderNum(int orderNum) {
Record record = findRecordByNum(orderNum);
if (record != null) {
int index = indexOfRecord(record);
if (index >= 0) {
int numMoved = records.length - index - 1;
if (numMoved > 0) {
System.arraycopy(records, index + 1, records, index, numMoved);
}
records = Arrays.copyOf(records, records.length - 1);
}
}
}
private int indexOfRecord(Record record) {
for (int i = 0; i < records.length; i++) {
if (records[i] == record) {
return i;
}
}
return -1;
}
public int getTotalPrice() {
int totalPrice = 0;
for (Record record : records) {
totalPrice += record.getPrice();
}
return totalPrice;
}
public Record findRecordByNum(int orderNum) {
for (Record record : records) {
if (record.getOrderNum() == orderNum) {
return record;
}
}
return null;
}
public void printOrder() {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("桌号：" + tableNum + " 时间：" + dateFormat.format(time));
System.out.println("菜品\t\t\t单价\t\t数量\t\t小计");
for (Record record : records) {
System.out.println(record.getDish().getName() + "\t\t\t" + record.getDish().getPrice() + "\t\t" +
record.getPortion() + "\t\t" + record.getPrice());
}
System.out.println("总计：" + getTotalPrice());
}
}
class Record {
private int orderNum; // 序号
private Dish dish; // 菜品
private int portion; // 份额
public Record(int orderNum, Dish dish, int portion) {
this.orderNum = orderNum;
this.dish = dish;
this.portion = portion;
}
public int getOrderNum() {
return orderNum;
}
public Dish getDish() {
return dish;
}
public int getPortion() {
return portion;
}
public int getPrice() {
return dish.getPrice(portion);
}
}
public class Main {
public static void main(String[] args) {
// write your code here
}
}
菜品类用于描述餐厅菜品的基本信息和价格。它包括了名称、类型、基础价格和特色值等信息。通过这个类，我们可以获取菜品的价格，判断菜品是否辣、酸或甜，以及添加菜品的特色值等。这个类的实现中，使用了Java的日期类和日历类来判断当前是否是周末，并提供了一些用于判断菜品是否辣、酸、甜的方法，例如isSpicy()、isSour()和isSweet()等方法。同时，这个类还提供了一个用于计算菜品价格的方法getPrice()，它会根据菜品类型和当前是否是周末来计算菜品的价格。这个类还提供了一个addFeature()方法，用于添加菜品的特色值
菜单类用于管理菜单上的菜品。它包括了添加、删除、搜索和获取总价格等功能。其中，菜品信息是用Dish类来表示的，每个菜品包括名称、类型、价格和特色等信息。这个类通过使用Java的集合类ArrayList来存储菜品信息，并提供了一些操作这个集合的方法。例如，addDish()和addSpecialDish()方法用于向菜单中添加菜品，removeDish()方法用于删除菜品，searchDish()方法用于根据菜品名称查找菜品，getTotalPrice()方法用于获取所有菜品的总价格。同时，这个类还提供了一个printMenu()方法，用于将菜单信息打印出来。
订单类用于记录餐厅客人点餐的订单信息。它包括了桌号、时间、订单记录和菜单等信息。其中，每个订单记录是用Record类来表示的，每个记录包括订单号、菜品、份量等信息。这个类提供了添加、删除、查找和获取总价格等功能。例如，addARecord()方法用于向订单中添加订单记录，delARecordByOrderNum()方法用于根据订单号删除订单记录，findRecordByNum()方法用于根据订单号查找订单记录，getTotalPrice()方法用于获取所有订单记录的总价格。同时，这个类还提供了一些获取订单信息的方法，例如getTableNum()和getTime()等方法。这个类的实现中，使用了Java中的数组来存储订单记录，并提供了一些操作这个数组的方法。
订单记录类包含了一些成员变数和方法。其中，成员变数包括"orderNum"（订单编号、"dish"（菜品）和"portion"（份量）；而方法包括建构子"Record"、getter方法"getOrderNum"、"getDish"和"getPortion"，以及计算价格的方法"getPrice"。看上去这个类别是为了记录订单的信息而设计的。
3、测验1-圆类设计
1 import java.util.Scanner;
2 class Circle{
3 private double r;
4 double getArea(double r){
5 double area;
6 area=Math.PI*r*r;
7 return area;
8 }
9 }
10 public class Main{
11 public static void main(String[] args){
12 Scanner scanner=new Scanner(System.in);
13 double ra=scanner.nextDouble();
14 if(ra<=0){
15 System.out.println("Wrong Format");
16 }else{
17 Circle circle=new Circle();
18 double a=circle.getArea(ra);
19 System.out.println(String.format("%.2f",a));
20 }
21 }
22 }
这段Java程式码定义了一个名为" Circle "的类别，该类别包含了一个成员变数" r "（半径），以及一个计算圆面积的方法" getArea " 。接着，定义了一个名为" Main "的公开类别，包含了一个main方法，用于进行程序的执行。
在main方法中，宣告了一个Scanner物件" scanner "，用于读取用户从终端输入的数据。接着，从用户输入中读取一个double型数据" ra "，并进行条件判断。如果" ra "小于等于0 ，则输出" WrongFormat "；否则，创建一个Circle的实例" circle "，并调用其getArea方法，传入" ra "作为参数，计算圆的面积" area "。最后，使用System.out.println方法输出" area "，并使用String.format方法将其格式化为只保留两位小数的字串。
4、测验2-类结构设计
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double x1=input.nextDouble();
double y1=input.nextDouble();
double x2=input.nextDouble();
double y2=input.nextDouble();
double area=Math.abs(x1-x2)*Math.abs(y1-y2);
System.out.println(String.format("%.2f",area));
}
}
这段Java程式码定义了一个公开类别" Main "，在main方法中，宣告了一个Scanner物件" input " ，用于读取用户从终端输入的数据。接着，从用户输入中读取四个double型数据" x1 "、 " y1 " 、 " x2"以及" y2 "。这四个数据代表了一个矩形的两个对角点坐标。
然后，程式码使用Math.abs方法计算出了矩形的面积" area "。具体地，将x1和x2的差值取绝对值，乘以y1和y2的差值取绝对值，即可得到矩形的面积。
最后，使用System.out.println方法输出" area " ，并使用String.format方法将其格式化为只保留两位小数的字串
5、测验3-继承与多态
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double area;
int choice=input.nextInt();
switch(choice){
case 1:
double radiums=input.nextDouble();
area=Math.PI*radiums*radiums;
if(radiums<=0){
System.out.println("Wrong Format");
}else{
System.out.println(String.format("%.2f",area));
}
break;
case 2:
double x1=input.nextDouble();
double y1=input.nextDouble();
double x2=input.nextDouble();
double y2=input.nextDouble();
area=Math.abs(x1-x2)*Math.abs(y1-y2);
System.out.println(String.format("%.2f",area));
break;
}
}
}
此程序代码可以接受用户的输入，然后根据用户的输入计算出圆形或矩形的面积，并输出结果。其中，输入使用了Scanner类，可以接收用户从命令行输入的数据。switch语句根据用户的输入做出不同的计算操作。如果用户输入的数值不符合要求，程序会输出Wrong Format。输出结果为保留两位小数的面积值。
6、测验4-抽象类与接口
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double[] area=new double[1000];
int count=0;
int choice=input.nextInt();
while(choice!=0){
switch(choice){
case 1:
double radiums=input.nextDouble();
area[count]=Math.PI*radiums*radiums;
if(radiums<=0){
System.out.println("Wrong Format");
}else{
count++;
}
choice=input.nextInt();
break;
case 2:
double x1=input.nextDouble();
double y1=input.nextDouble();
double x2=input.nextDouble();
double y2=input.nextDouble();
area[count]=Math.abs(x1-x2)*Math.abs(y1-y2);
count++;
choice=input.nextInt();
break;
}
}
for(int i=0;i<count;i++){
for(int j=i;j<count;j++){
if(area[i]>area[j]){
double temp=0.0;
temp=area[i];
area[i]=area[j];
area[j]=temp;
}
}
System.out.print(String.format("%.2f",area[i])+" ");
}
}
}
这段程序代码可以接受用户的输入，然后根据用户的输入计算出圆形或矩形的面积，并将计算出的面积值存储在数组中。程序可以进行多次计算，用户输入0时程序停止运行。通过双重for循环，程序对数组中的元素进行排序，并输出排序后的结果。主要使用了while循环和双重for循环来实现。
程序中，输入使用了Scanner类，可以接收命令行输入的数据。数组area用于存储计算出的面积值，count记录数组中元素的数量。while循环根据用户的输入做出不同的计算，如果用户输入的数值不符合要求，程序会输出Wrong Format。程序将计算出的面积值存储在数组中，并且通过count进行计数，同时更新用户的选择。最后，通过双重for循环，程序对数组中的元素进行排序，并输出排序后的结果。
三、踩坑心得
1、注意数据类型的匹配，避免数据类型转换错误。
2、如果程序出现错误，要注意查看错误提示信息，可以帮助找到错误所在。
3、注意程序的边界情况，例如输入为负数的情况、输入为0的情况等等。
4、对于循环和条件语句，要注意循环变量的初始值、循环条件的限定以及循环变量的增减。
5、要注意变量的作用域，确保变量在使用前已经被初始化。
6、注意代码的可读性和规范性，使用语义明确的变量名和方法名，遵循编码规范。
7、对于涉及数组的题目，要注意数组下标的限制，避免数组越界错误。
8、善于利用调试工具，可以帮助定位程序出现错误的位置。
四、改进建议
确保代码是自己或其他人可以理解的。这意味着注释代码并确保使用清晰的变量名和函数名。这样可以使代码更容易维护和修改。
五、总结
在Java课程的6-9周中，我学到了Java的基本语法、面向对象编程思想、数据类型、循环、条件语句、数组、字符串操作、类的设计、正则表达式、继承等。为了进一步提高我的Java编程能力，我尝试自己从零开始编写一些小的Java程序，以提高自己的实战经验。
对于教师和课程方面，建议教师可以在课堂上加强实践环节，让学生们更深入地了解Java编程。另外，也可以邀请一些专业的Java工程师或者行业内的讲师来给学生讲解一些实际应用场景和案例，以帮助学生更好地理解Java技术。
在作业和实验方面，建议增加一些综合性、实践性强的项目，让学生们能够更加深入地应用Java编程知识。
最后，课上和课下的组织方式可以更加灵活多样，可以结合线上和线下的方式，采用多种教学手段和资源，满足学生不同的学习需求。
标签：return,String,期中考试,PTA,int,菜品,dish,题目,public From： https://www.cnblogs.com/xzyblog/p/17405837.html