BLOG1

一、前言

这是我Java三次大作业的总结，思考和一些其他的想法。

菜单类题目之外的其他的小题目都还好，差不多都做出来了，在做这些题目的同时我也学会了很多java语言的知识，明白了合理用JAVA中包含的自带的函数是一种便捷高效的方法，比如第二次大作业中的7-3，合理使用import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;import java.util.Scanner;Calendar cal = Calendar.getInstance();cal.setTime(date1);等可能是做出这道题的必要条件，我在没有使用这些是做的十分费力，且最后没有做出来，提交不通过。

在这三次作业中，我菜单类题目写的总体来说让我很不满意，只有第一次的菜单题写出来了，拿了满分。在接下来的分析中，我会主要分析三次菜单类作业。

二、设计与分析 

第一道菜单类题目：

我的代码：

import java.util.Scanner;

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) {
if (portion == 1) {
return unit_price;
} else if (portion == 2) {
return (int) Math.round(unit_price * 1.5);
} else if (portion == 3) {
return unit_price * 2;
} else {
return 0;
}
}
}

class Menu {
Dish[] dishs = new Dish[] {
new Dish("西红柿炒蛋", 15),
new Dish("清炒土豆丝", 12),
new Dish("麻婆豆腐", 12),
new Dish("油淋生菜", 9)
};

Dish searchDish(String dishName) {
for (Dish dish : dishs) {
if (dishName.equals(dish.name)) {
return dish;
}
}
return null;
}
}

class Record {
Dish d;
int portion;

int getPrice() {
if (portion != 1 && portion != 2 && portion != 3) {
return 0;
}
return d.getPrice(portion);
}
}

class Order {
Record[] records;
int numRecords;

Order() {
records = new Record[100];
}
Menu menu=new Menu();
Record addARecord(String dishName, int portion) {
Record record = new Record();
Dish dish = menu.searchDish(dishName);
if (dish == null) {
System.out.println(dishName + " does not exist");
return null;
} else {
record.d = dish;
record.portion = portion;
records[numRecords++] = record;
return record;
}
}

int getTotalPrice() {
int totalPrice = 0;
for (int i = 0; i < numRecords; i++) {
totalPrice += records[i].getPrice();
}
return totalPrice;
}
}

public class Main {
static Menu menu = new Menu();

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Order order = new Order();
String dishName;
int portion;

while (true) {
dishName = input.next();
if (dishName.equals("end")) {
break;
}
portion = input.nextInt();
Record record = order.addARecord(dishName, portion);
if (record != null && record.getPrice() == 0) {
System.out.println(dishName + " portion " + portion + " does not exist");
}
}

System.out.println(order.getTotalPrice());
}
}

设计与分析：

这道题目要求我们设计一个点菜计价程序，根据输入的订单，计算并输出总价格。我们需要设计四个类：Dish类、Menu类、Record类和Order类。

首先，我们来看Dish类。Dish类是对应菜谱上一道菜的信息，需要包含菜品名称和单价两个属性，以及一个计算菜品价格的方法。这个计算价格的方法需要一个参数portion，表示点菜的份额。我们可以根据题目中的计价规则，使用基础价格乘以对应的份额对单价进行计算，再根据四舍五入的规则进行处理。

接下来是Menu类，它对应整个菜谱，需要包含一个菜品数组dishs保存所有菜品信息，以及一个根据菜名查找菜品信息的方法searthDish。这个方法需要遍历dishs数组，在其中查找包含对应菜名的Dish对象并返回。

最后是Order类，它需要保存用户点的所有菜的信息，包括多个Record对象，以及一个计算订单总价的方法getTotalPrice和添加一条菜品信息到订单中的方法addARecord。这个方法需要根据菜名和份额，从菜谱中查找对应的Dish对象，并创建一个Record对象，添加到订单中。

最后，我们可以根据题目要求，构造一个命令行程序来测试我们的类。在程序中，我们需要先创建一个菜谱menu对象，包含饭店提供的所有菜的信息。然后，我们可以循环读入每一条点菜记录，并使用addARecord方法将菜品信息添加到订单中，直到用户输入end为止。最后，我们可以调用Order类的getTotalPrice方法，计算订单的总价，并输出给用户。

第二道菜单类题目：

我的代码：

import java.util.Scanner;

class Dish {
// 菜品
String name; // 菜品名称
int unit_price; // 单价

int getPrice(int portion) {// 计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
switch (portion) {
case 1:
return Math.round(unit_price);
case 2:
return Math.round(unit_price * 1.5f);
case 3:
return Math.round(unit_price * 2f);
default:
return 0;
}
}
}

class Menu {
// 菜谱

// this.dishs = new Dish[0];
Dish[] dishs;// 菜品数组，保存所有菜品信息

public Menu() { // 构造函数初始化空数组
this.dishs = new Dish[0];
}

Dish searchDish(String dishName) {// 根据菜名在菜谱中查找菜品信息，返回Dish对象。
for (int i = dishs.length - 1; i >= 0; i--) {
if (dishs[i].name.equals(dishName)) {
return dishs[i];
}
}
return null;
}

Dish addDish(String dishName, int unit_price) {// 添加一道菜品信息
Dish dish = new Dish();
dish.name = dishName;
dish.unit_price = unit_price;
Dish[] newDishs = new Dish[dishs.length + 1];
System.arraycopy(dishs, 0, newDishs, 0, dishs.length);
newDishs[dishs.length] = dish;
dishs = newDishs;
return dish;
}
}

class Record {
// 点菜记录
int orderNum;// 序号
Dish d;// 菜品
int portion;// 份额（1/2/3代表小/中/大份）
int num;// 数量

int getPrice() {// 计价，计算本条记录的价格
return d.getPrice(portion) * num;
}
}

class Order {
// 订单
Record[] records = new Record[0];// 保存订单上每一道的记录

int getTotalPrice() {// 计算订单的总价
int total = 0;
for (Record r : records) {
total += r.getPrice();
}
return total;
}

Record addARecord(int orderNum, String dishName, int portion, int num) {// 添加一条菜品信息到订单中。
Record record = new Record();
record.orderNum = orderNum;
Menu menu = Main.menu;
Dish dish = menu.searchDish(dishName);
if (dish == null) {// 不能识别的菜名
System.out.println(dishName + " does not exist");
return null;
}
record.d = dish;
record.portion = portion;
record.num = num;
Record[] newRecords = new Record[records.length + 1];
System.arraycopy(records, 0, newRecords, 0, records.length);
newRecords[records.length] = record;
records = newRecords;
return record;
}

void delARecordByOrderNum(int orderNum) {// 根据序号删除一条记录
Record[] newRecords = new Record[records.length];
int i = 0;
for (Record r : records) {
if (r.orderNum != orderNum) {
newRecords[i++] = r;
}
}
if (i == records.length) {// 没有这个序号
System.out.println("delete error");
} else {
records = newRecords;
}
}

Record findRecordByNum(int orderNum) {// 根据序号查找一条记录
for (Record r : records) {
if (r.orderNum == orderNum) {
return r;
}
}
return null;
}
}

public class Main {
static Scanner sc = new Scanner(System.in);
static Menu menu = new Menu();
static Order order = new Order();

public static void main(String[] args) {
String input;
while (true) {
input = sc.nextLine();
if (input.equals("end")) {
break;
}
String[] parts = input.split(" ");
if (parts.length == 2&&parts[0].length()!=1) {// 菜单
String dishName = parts[0];
int unit_price = Integer.parseInt(parts[1]);
menu.addDish(dishName, unit_price);
} else {// 订单
int orderNum = Integer.parseInt(parts[0]);
if (parts[1].equals("delete")) {// 删除记录
order.delARecordByOrderNum(orderNum);
} else {// 点菜记录
String dishName = parts[1];
int portion = Integer.parseInt(parts[2]);
int num = Integer.parseInt(parts[3]);
order.addARecord(orderNum, dishName, portion, num);
}
}
}

for (Record r : order.records) {
System.out.print(r.orderNum + " " + r.d.name + " ");
if (r.d == null) {
continue;
}
System.out.println(r.getPrice());
}

System.out.println(order.getTotalPrice());
}
}

 设计与分析：

这题的设计框架大体上与前一题类似，但有增加的地方：

如：输入内容按先后顺序包括两部分：菜单、订单，菜品记录，点菜记录，删除记录等。

题目要求我们实现一个点餐计价程序，程序通过输入菜单和订单信息来计算餐费，并输出处理信息和总价格。输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

首先我们需要定义一些类来表示不同的数据元素。题目中需要我们定义菜品类（Dish）、菜谱类（Menu）、点菜记录类（Record）和订单类（Order）。

菜品类表示一道菜的信息，包括菜名和基础价格。其中菜名是字符串类型，基础价格是整数类型。菜品类还需要一个方法getPrice，用于根据点菜的份额计算这道菜的价格。这个方法需要一个整数参数portion，输入数据只能是1/2/3，代表小/中/大份。根据不同的份额，菜品的价格有不同的计算方法，小份菜的价格=菜品的基础价格，中份菜的价格=菜品的基础价格1.5，大份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。

菜谱类表示一个饭店提供的所有菜的信息，包括若干个菜品对象。菜谱类需要一个数组属性dishes，用于保存所有菜品的信息。菜谱类还需要两个方法：searchDish和addDish。前者用于根据菜名在菜谱中查找菜品信息，返回Dish对象；后者用于在菜谱中添加一道新菜品的信息，如果存在同名的菜品，则更新菜品的基础价格。

点菜记录类表示订单上的一道菜品记录。包括序号、菜品、份额和份数。其中菜品是Dish类型，表示点的是哪一道菜。点菜记录类还需要一个方法getPrice，用于计算本条记录的价格，价格等于对应记录的菜品价格*份数。

订单类表示用户点的所有菜的信息。包括若干个点菜记录对象。订单类需要一个数组属性records，用于保存所有点菜记录的信息。订单类还需要三个方法：getTotalPrice、addARecord和delARecordByOrderNum。前者用于计算订单的总价，遍历订单中的所有点菜记录，调用getPrice方法计算每道菜的价格并累加，得到总价。后两个方法用于添加一条菜品信息到订单中和根据序号删除一条记录，具体实现可以直接参考上面的代码。

最后，在主程序中，我们需要先输入菜单信息，并将所有菜品信息存储到菜谱中。然后，输入订单信息，对于每一条点菜记录，我们需要调用订单类的addARecord方法来添加到订单中，对于每一条删除信息，我们需要调用订单类的delARecordByOrderNum方法来删除。最后，需要输出所有点菜记录的处理信息，每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品份数。如果订单中包含不能识别的菜名，则输出“* does not exist”，**是不能识别的菜名。如果删除记录的序号不存在，则输出“delete error”。最后，还需要输出订单上所有菜品的总价（整数数值）。

 第三道菜单类题目：

 

这道题在pta提交之前我没有做出来，这是我后来写完的：

 

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.HashMap;

import java.util.Scanner;

public class Main {

private static HashMap<Integer, Table> tables = new HashMap<>();

private static final int MAX_HOUR = 22; // 最晚的开放时间

private static final int MIN_HOUR = 9; // 最早的开放时间

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    while (sc.hasNext()) {
        String cmd = sc.next();
        if (cmd.equals("table")) {
            handleOpenTable(sc);
        } else if (cmd.equals("delete")) {
            handleDelete(sc);
        } else if (cmd.equals("end")) {
            handleEnd();
            break;
        } else {
            handleOrder(cmd, sc);
        }
    }
    sc.close();
}

private static void handleOpenTable(Scanner sc) {
    int tableId = sc.nextInt();
    String dateStr = sc.next();
    String timeStr = sc.next();
    int year = Integer.parseInt(dateStr.split("/")[0]);
    int month = Integer.parseInt(dateStr.split("/")[1]);
    int day = Integer.parseInt(dateStr.split("/")[2]);
    int hour = Integer.parseInt(timeStr.split(":")[0]);
    LocalDateTime openTime = LocalDateTime.of(year, month, day, hour, 0, 0);
    if (hour < MIN_HOUR || hour > MAX_HOUR) {
        System.out.println("table " + tableId + " out of opening hours");
        return;
    }
    tables.put(tableId, new Table(openTime));
}

private static void handleDelete(Scanner sc) {
    String secondArg = sc.next();
    if (secondArg.equals("table")) {
        int tableId = sc.nextInt();
        Table table = tables.get(tableId);
        if (table == null) {
            System.out.println("table " + tableId + " not found");
        } else {
            table.close();
            tables.remove(tableId);
        }
    } else {
        int tableId = Integer.parseInt(secondArg);
        Table table = tables.get(tableId);
        if (table == null) {
            System.out.println("table " + tableId + " not found");
        } else {
            String dishName = sc.next();
            int amount = sc.nextInt();
            table.removeOrder(dishName, amount);
        }
    }
}

private static void handleOrder(String dishName, Scanner sc) {
    int amount = sc.nextInt();
    double price = sc.nextDouble();
    int tableId = sc.nextInt();
    Table table = tables.get(tableId);
    if (table == null) {
        System.out.println("table " + tableId + " not found");
    } else if (table.isClosed()) {
        System.out.println("table " + tableId + " is closed");
    } else {
        table.addOrder(dishName, amount, price);
    }
}

private static void handleEnd() {
    for (Table table : tables.values()) {
        if (!table.isClosed()) {
            table.close();
        }
    }
    for (int tableId : tables.keySet()) {
        Table table = tables.get(tableId);
        System.out.println("table " + tableId + ":");
        for (Order order : table.getOrders()) {
            System.out.printf("%d %s %.0f\n", order.getAmount(), order.getName(), order.getPrice());
        }
        System.out.printf("%.0f\n", table.getTotalPrice());
    }
}

}

class Table { private LocalDateTime openTime; // 开桌时间

private LocalDateTime closeTime; // 结账时间

private double totalPrice; // 总价

private HashMap<String, Integer> orders = new HashMap<>(); // 菜品列表

public Table(LocalDateTime openTime) {
    this.openTime = openTime;
}

public void addOrder(String dishName, int amount, double price) {
    if (orders.containsKey(dishName)) {
        orders.put(dishName, orders.get(dishName) + amount);
    } else {
        orders.put(dishName, amount);
    }
    totalPrice += price * amount;
}

public void removeOrder(String dishName, int amount) {
    if (!orders.containsKey(dishName)) {
        System.out.println(dishName + " does not exist");
    } else {
        int currAmount = orders.get(dishName);
        if (currAmount < amount) {
            System.out.println("delete error");
        } else {
            double price = currAmount == amount ? 0 : getDishPrice(dishName) / currAmount * amount;
            orders.put(dishName, currAmount - amount);
            totalPrice -= price;
        }
    }
}

public void close() {
    closeTime = LocalDateTime.now();
}

public boolean isClosed() {
    return closeTime != null;
}

public double getTotalPrice() {
    return totalPrice;
}

public Order[] getOrders() {
    Order[] result = new Order[orders.size()];
    int i = 0;
    for (String name : orders.keySet()) {
        result[i++] = new Order(name, orders.get(name), getDishPrice(name) / orders.get(name));
    }
    return result;
}

// 根据菜名返回单价
private double getDishPrice(String dishName) {
    switch (dishName) {
        case "麻婆豆腐":
            return 12;
        case "油淋生菜":
        return 9;
         case "麻辣鸡丝":
         return 5; 
          default: 
          return 0; 
           } 
           }
            }

class Order { private String name; private int amount; private double price;

public Order(String name, int amount, double price) {
    this.name = name;
    this.amount = amount;
    this.price = price;
}

public String getName() {
    return name;
}

public int getAmount() {
    return amount;
}

public double getPrice() {
    return price;
}

}

 

设计与分析：

 

 

这题的设计框架大体上与前两题类似，但有增加的地方：

 如：桌号标识，代点菜信息，折扣的计算方法等。

在这个实现中，由于时间和日期的格式比较复杂，我使用了Java自带的DateTimeFormatter库来解析和格式化时间。对于每个桌子，使用一个Table对象来表示，其中包括了开桌时间、结账时间、菜品列表以及总价等信息。对于每个菜品，使用一个Order对象来表示，其中包括了菜名、数量和单价等信息。

除了时间和日期的处理，这个实现的关键在于如何正确地处理各种情况下的输入和输出。在处理输入时，需要根据命令类型进行不同的操作。对于开桌操作，需要解析日期和时间，检查是否在开放时间内，并创建一个新的Table对象来表示这张桌子。对于点餐操作，需要在对应的Table对象上添加一个新的Order对象。对于删除操作，需要先判断是桌子删除还是菜品删除，然后在对应的Table对象上执行相应的操作。

在处理输出时，首先需要将所有未结账的桌子都进行结账操作。对于每张桌子，需要先输出所有点过的菜品和对应的数量和单价，最后输出总价。在输出菜品时，可以根据菜品名称来查询对应的单价，从而方便地计算出总价。

三、踩坑心得

写第二次作业时，对于题目的难度，时间的紧迫性没有概念，是我没有在题目发布后第一时间开始着手写，耽误了一点时间。不过在写第三次作业时就没有了，以后也不会了。

 类名，对象名，一定要见名知意，这在以前体会还不这么强烈，在一题的代码上了几百行的代码之后，体会很深刻了。写到后面几乎不记得前面写了什么。

注释尽量详细，要保证自己能看得懂。这和上一点是一样的。要让自己快速回忆起前面写了什么。

有一道题是和计算机的精度相关的，那道题的知识点是计算机的精度是有限的。

多看Java自带的类的文档，在Java的标准库中，包括了许多功能强大的类和方法，它们可以减少编写代码的工作量，提高代码的可读性和可维护性。这些类和方法的使用方法和参数说明都有详细的文档，我们应该充分利用这些文档，掌握Java的各种特性。极大地提高了Java编程的效率和质量。

我在日常做题时，可以利用java自带的函数库，来实现一些问题，从而可以避免很多不必要的麻烦，也可以使代码更加工整。

四、困难，改进建议及总结

第一次大作业，应该是老师为了让我们适应一下JAVA编程，出了一些比较基础的题目，让我们来练练手，熟悉一些语法和基本的编程格式、 语法及其它。这次作业给我的感觉就是刚刚好，让我花费了一些时间和精力，但又不至于太多或太少，写完这次作业后感觉心情很愉快，我也得了满分。

 重点说菜单类题目，第二次大作业加入了点菜系列，有两道点菜类的题目和两道其他题目。其中第一道点菜类题目提交了十次左右，最后拿到了满分。我知道第二题是建立在第一题基础上的，我本来以为第一题写完之后，我写第二题应该能轻松一些，肯定能写 的出来，没想到 就在这遇到了我编程学习人生中的斯大林格勒战役，先是编译器给我无穷无尽的报错，就是不让我编译过去，好不容易调试过去不报错之后，我提交他又一个测试点都没过， 格式错误，非零返回，段错误，输出超限等多种错误，有些错误我都还第一次见。

 然后就一直改改改，查查查，查各种资料， 看语法书，问百度知乎(网上好像都没有这种类型的或者相似的题目，我能查到的最似的是一个40行左右代码的外国的点餐题，但是几乎没什么可以学习的东西)，然后过了九个测试点拿了14分，再往后就是举步维艰了，经常把这个东西改一下，又影响到别的地方的代码了，然后分数或者毫无变化，或者不增反减。

 本来是说星期天晚上12点截止嘛，我星期天早上或者说上午我这道题就是14分(其他的题目都已经结束战斗了)，然后一直到半夜12点截止时，我还是14分。(我是眼睁睁看着截止的倒计时一秒秒走完的，那天晚上我快1点睡)

 第一题写完时，我还以为我第一题搞懂了，结果第二题告诉我:不！你没有搞懂，你什么都不会。然后时间又延了两天，竟然，仍旧一个测试点也没过，就这样一分都没有加，我都要崩溃了。

  这可能是我啃过最硬的骨头了，可这也太硬了吧，感觉已经超出我的能力范围了，不知道是不是我不适应这种教学方式还是怎么回事，又或者是我单纯和这道题不合？我自认为已经在很努力的写这道题了，星期天上午，下午，晚上还有延期的这两天我别的什么课都没复习，其他什么作业都没有写，就专门在学java写这道题。

 不过可能这时我心态就有些问题了，有些太过于焦虑和压抑，感觉都要出精神问题了(自我感觉，也可能没那么严重)。心理学上确实有这种现象，一个人越是拼命的想做某件事或者越是集中精力做某件事或者解决某个问题就越做不成或者越解决不了，也许当时我如果能平复下心情或者多做几次深呼吸，做做心灵调节保健操，或者能出去转两圈，散散步，呼吸一下新鲜空气，可能是我思路还能可以更开阔一点，头脑还能更清晰一些，退一万步来说，就算最后也没做出来，也不至于在这个过程中这么痛苦，焦虑，担心，感觉这次作业对我整体的心理状况和心理健康都有一点影响，我觉得这和我第三次菜单类作业也没全做出来有些关系。

最让我难过的是，这是我第一次pta没有得满分。而且不仅没有得满分，是直接59分不及格，对我打击还是很大的。搞得我这段时间心情都比较低落，还影响了下一次写菜单类的题目作业。

然后就是第三次作业，有了上次，这种题写很久也可能写不出来的经验，这次我先把其他的题给写完了，然后开始专门攻这道题。（这是个相当正确的做法，这次作业唯一值得安慰的是，这次其他题目有七十分，我全做出来了，所以终于没有不及格了。。。）我先是写了400行左右的代码，本来想先运行下试试看，可惜提交时它显示代码长度超过限制，提交不了，后来删了一些，改了一些，到两三百行还是太长提交不了(其实这我觉得很奇怪的)，后来重新从头写的时，我想到第一次在那里作业的时候，班上有个同学用面向过程的编程方法写，那一题拿了满分，我想要不先把分拿到再说吧，也许我有面向过程的方法写能多拿一些分，毕竟上次这类题我用面向对象的编程方法，40分就拿了14分。

我心里想的是先有面向过程的编写方式写，先把分拿到手。然后再有面向对象的方式重新再写一遍，这样我我心里会好受一些，精神压力不会那么大，我心想不要搞得跟上次一样，都提交最后一秒，还那么点分。然后我就开始写了，然而这个过程比我想象的要复杂的多，用的时间比我想象中长的多，可能是受了老师讲课时举的例子说的话的影响，我以为这道题用面向过程的编程方式编写，挺简单的，但是这道题是用面向过程的方法编写，也很复杂，我写到100多快200行代码的时候就已经挺后悔了，不过已经接近我尾声了，我也就继续写下去了。

写完后提交发现有些错误，编译不过去，调试了几遍后，终于编译过去了，提交成功得了一分，我觉得我心里要崩溃了，把那串代码调整了一下，改了又改之后，改到了125行，提交，结果还是一分。我心里很难过，但是已经很晚了， 我努力的用勉强对象的方法，从头再写这道题的代码，但是没来得及在截止日期之前提交。现在回头想想，我有想过程的方法，写这道代码是很不理智的行为，因为即使多拿了些分，也没什么意义，因为这门课培养的其实是面向对象的这种思维方式，这是老师在上第一堂课的时候就说了的，而且在平时上课时，也不断的强调。浪费那么多时间在有面向过程的方法写这道题的代码是很不值得的。

可能是我对这道实在是有些怕了，从心里觉得他很难很难，可能做不出来，又害怕分数低，排名低，不如别人，就更多的想着把分拿到手了。

我希望以后自己能摆正心态，用一个良好的心态做题，努力在做题中学习JAVA知识，理解面向对象过程编程的思想和特点。

下面是我的一些思考：

1.学习更多的算法

2.持续练习编写代码：编程不仅在于掌握知识点，还需要不断练习才能更好地理解和应用它们。因此，在学习Java编程的过程中，尽可能多地编写代码，并进行正确的测试来加深对编程语言和程序设计的理解。

3.总结和反思：每个作业完成后，要回顾自己在写的过程中掌握的新知识，新技能，增强对Java本身的深入了解。及时调整自己的知识和学习计划，不断改进和提高。

4.掌握工具

5.提高面向对象编程的能力：Java是一门面向对象的编程语言，掌握面向对象编程的思想和技术是非常重要的。要理解面向对象编程的基本概念，如类、对象、继承、多态等等。

想对老师说的话：

这菜单类的题目对我来说太难了，如果可能的话，下次题目一次难度不要上升这么大。

也可以给其他的小题目，基础的题目更多的占比和得分。

就像第三次大作业一样，其他题目70分，也不至于说，一道题做不出就直接不及格。

还有这个菜单类的题目，可能还有其他的作业里的题目，但主要是菜单类题目，我们希望上课能详细讲一下，或者至少给我们一个参考答案。要不然不会的，我们总是不会，如果做不出来，那就是做不出来。您既然说了会查重，我们也不可能去问同学，同学也不会把自己代码给我，怕和我的查重。我曾经就Pta上的问题问过两次同学，他们的回答十分简单且敷衍。我希望老师能注重一下，PTA作业截止之后，让我把不懂的东西搞懂，要不然我们不会的总是不会，而且甚至都不知道自己哪里不会。Pta上截止时间过了之后，提交都提交不了，再改代码都不知道自己的代码是不是改对能通过测试点了。

本栏目推荐文章
• 如何写出漂亮代码 https://libin9ioak.blog.csdn.net/article/details/127749042
• AIX Oracle 11.2.0.4打PSU crsconfig_lib.pm line 11821解决 (转自：https://blog.csdn.net/jwocnimabi/article/details/125440561)
• BLOG-3
• blog-3
• Blog-3
• BLOG-3
• blog-3
• JAVA BLOG-3
• BLOG3
• blog3-期末