PTA第二次总结

这次重点是菜单迭代4和5，由于菜单迭代3中我还是按照面向过程的思路做，所以到了迭代4我就寸步难行，于是我决定重新画类图并重构代码。

下面是我的重构后的类图：

 这里左边是正常情况下的类图，面对迭代4中的异常情况我是新建了抽象检查类，在左边的正常情况中对需要检查的地方插入检查类，像拼积木一样需要检查什么就拿什么插入。

可惜做到后面发现类图缺少了保存时间的属性，导致我最后一个测试点没通过。

下面是迭代4的题目

Menu4

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

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

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

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

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

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

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

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

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

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

删除记录格式：序号 delete

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

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

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

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

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

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

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

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

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

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

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

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

Dish {

String name;//菜品名称

int unit_price; //单价

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

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

Menu {

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

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

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

}

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

Record {

int orderNum;//序号

Dish d;//菜品\\

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

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

}

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

Order {

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

例如：麻婆豆腐 9 T

菜价的计算方法：

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

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

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

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

输入格式:

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

菜品记录格式：

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

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

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

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

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

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

输出格式:

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

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

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

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

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

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

评测详情

 

测试点	提示	内存(KB)	用时(ms)	结果	得分
case0	包含混合在订单信息中的菜谱信息。之后的用例简称此情况为混合的菜谱信息。	24692	381	答案正确	2 / 2
case1	重复的删除记录	24708	377	答案正确	3 / 3
case2	包含错误的份数。	25376	436	答案正确	3 / 3
case3	包含错误的份额。	23868	395	答案正确	2 / 2
case4	桌号信息格式错误	15608	150	答案正确	3 / 3
case5	桌号信息格式错误:多余字符	15384	151	答案正确	2 / 2
case6	桌号信息格式错误：多余字符	15692	152	答案正确	2 / 2
case7	混合错误：桌号信息格式错误+混合的菜谱信息（菜谱信息忽略）	16064	153	答案正确	2 / 2
case8	混合错误：菜谱记录格式错误+混合的菜谱信息	25472	442	答案正确	2 / 2
case9	菜谱格式错误	23736	455	答案正确	3 / 3
case10	菜谱格式错误	24160	398	答案正确	2 / 2
case11	错误的菜谱信息	27200	482	答案正确	3 / 3
case12	包含空行（按错误的输入格式计）。	23840	390	答案正确	2 / 2
case13	包含混合在订单信息中的菜谱信息。	23308	373	答案正确	2 / 2
case14	混合错误：桌号信息格式错误+错误桌的订单记录格式错误（忽略，不输出）	15700	139	答案正确	2 / 2
case15	混合错误：桌号格式错误+订单格式错误+错误的混合菜谱信息（后面两个错误均不输出）	16020	134	答案正确	2 / 2
case16	混合错误：订单记录格式错误+混合菜谱信息	23868	335	答案正确	2 / 2
case17	桌号时间错误	24076	393	答案正确	3 / 3
case18	错误的table记录，内容并入上一个table计算。	23572	376	答案正确	2 / 2
case19	错误的table记录，	19376	221	答案错误	0 / 2
case20	重复的桌号，其中之一不在营业时间。	24924	417	答案正确	2 / 2
case21	重复的桌号，不同时间段。	24788	392	答案正确	2 / 2
case22	重复的桌号，在同一时间段。	23744	380	答案正确	2 / 2
case23	重复的桌号，一个桌号时间错误。	23852	373	答案正确	2 / 2
case24	多个桌号，一个桌号时间错误。	25836	395	答案正确	2 / 2
case25	多个桌号，一个桌号格式错误。	24124	343	答案正确	2 / 2
case26	多个桌号，一个桌号超出范围。	24828	368	答案正确	2 / 2
case27	多个桌号，一个桌号格式非法。	23884	340	答案正确	2 / 2
case28	多个桌号，一个桌号格式非法。	24960	359	答案正确	2 / 2
case29	代点菜信息，桌号不存在。	24084	340	答案正确	2 / 2
case30	代点菜信息，桌号不存在。	24748	368	答案正确	2 / 2
case31	菜谱价格超出范围	25120	348	答案正确	2 / 2
case32	桌号时间超出范围	24476	376	答案正确	2 / 2
case33	多桌菜测试，无异常记录	24180	367	答案错误	0 / 2
case34	桌号时间超过范围	23844	373	答案正确	2 / 2
case35	重复的菜名	23944	377	答案正确	2 / 2
case36	未按顺序排列的序号。	24332	347	答案正确	2 / 2
case37	代点菜	26928	442	答案正确	2 / 2
case38	多桌菜 错误的菜名 不在服务时间的桌号 等情况	24636	433	答案正确	2 / 2
case39	订单记录份额超出范围	24676	369	答案正确	3 / 3
case40	点菜记录份数超出范围	24404	349	答案正确	3 / 3
case41	点菜记录中包含多种错误	23992	416	答案正确	2 / 2
case42	点菜记录中包含多种错误	24660	403	答案正确	2 / 2
case43	桌号对应时间格式合法（符合题目中格式定义），数据非法	20376	262	答案正确	2 / 2
case44	桌号对应时间格式合法（符合题目中格式定义），数据非法	20576	252	答案正确	2 / 2
case45	重复的桌号，不同时间段。	25304	386	答案正确	2 / 2

 我的答案

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        input inputinpect = new input();
        time time = new time();
        table table = new table();
        Record replace = new vegetable();
        Record order = new order();
        Record special = new Specialtydishes();
        Menu menu = new Menu();
        TableIdentification tableIdentif = new TableIdentification();
        DeleteRecord delete = new DeleteRecord();
        OrderForGoods orderForGoods = new OrderForGoods();
        Scanner input = new Scanner(System.in);
        ArrayList<String> list = new ArrayList<String>();
        String iString;
        while (!"end".equals(iString = input.nextLine())) {
            if (iString.equals("")) { // 检查输入
                System.out.println("wrong format");
                continue;
            }
            if (table.starttable(iString.substring(0, 5))) { // 桌号标识
                
                
                for (String dan : iString.split(" "))
                    list.add(dan);
                if (!(tableIdentif.getTable() == 0)) {
                    tableIdentif.setotal();
                }
                try {
                    if(!iString.matches("table [1-9][\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?")) {
                    throw new iszero();
                }
                    tableIdentif.addtable(list.get(1), time.time(list.get(2) + " " + list.get(3)),
                            time.timeT(list.get(2) + " " + list.get(3)));

                } catch (  iszero | NumberFormatException e) {
                    tableIdentif.flag = true;
                    System.out.println("wrong format");
                }catch (ParseException e) {
                    tableIdentif.flag = true;
                    System.out.println(list.get(1) + " date error");
                } catch (tablenumoutofrange e) {
                    tableIdentif.flag = true;
                    System.out.println(list.get(1) + " table num out of range");
                } catch (timeOutOfRange e) {
                    tableIdentif.flag = true;
                    System.out.println("not a valid time period");
                } catch (timeOutOfopening e) {
                    tableIdentif.flag = true;
                    System.out.println("table " + list.get(1) + " out of opening hours");
                } catch (timeerror e) {
                    tableIdentif.flag = true;
                    System.out.println(list.get(1) + " date error");
                } finally {

                }
                list.removeAll(list);
                continue;
            }
            if (inputinpect.input(iString)) { // 检查输入
                if (tableIdentif.flag) {
                    break;
                }
                System.out.println("wrong format");
                continue;
            }
            for (String dan : iString.split(" "))
                list.add(dan);
            switch (list.size()) {
            case 2:
                if (tableIdentif.flag) {
                    break;
                }
                if (list.get(1).equals("delete")) { // 删除记录
                    delete.setOrdernum(list.get(0));
                    delete.DeleteRecord();
                } else {
                    if ((tableIdentif.getTable() == 0)) {
                        try {
                            menu.addDish(list.get(0), list.get(1));// 添加菜谱信息
                        } catch (iszero | NumberFormatException e) {
                            System.out.println("wrong format");
                        }

                    } else {
                        System.out.println("invalid dish");
                    }

                }

                break;
            case 3:
                if (tableIdentif.flag) {
                    break;
                }
                if ((tableIdentif.getTable() == 0)) {
                    try {
                        menu.addDish(list.get(0), list.get(1), list.get(2));// 添加特色菜
                    } catch (iszero | NumberFormatException e) {
                        System.out.println("wrong format");
                    }
                } else {
                    System.out.println("invalid dish");
                }
                break;
            case 4:

                // 添加点菜记录
                if (tableIdentif.flag) {
                    break;
                }
                try {
                    tableIdentif.addRecords(list.get(0), list.get(1), list.get(2), list.get(3));
                } catch (iszero | NumberFormatException e) {
                    System.out.println("wrong format");
                } catch (numOutOfRange e) {
                    System.out.println(list.get(0) + " num out of range " + list.get(3));
                } catch (portionOutOfRange e) {
                    System.out.println(list.get(0) + " portion out of range " + list.get(2));
                } catch (RecordOrdernumError e) {
                    System.out.println("record serial number sequence error");
                } finally {

                }

                break;
            case 5: // 添加带点菜记录
                if (tableIdentif.flag) {
                    break;
                }
                try {
                    tableIdentif.addRecords(list.get(0), list.get(1), list.get(2), list.get(3), list.get(4));
                } catch (iszero | NumberFormatException e) {
                    System.out.println("wrong format");
                } catch (numOutOfRange e) {
                    System.out.println(list.get(1) + " num out of range " + list.get(4));
                } catch (portionOutOfRange e) {
                    System.out.println(list.get(1) + " portion out of range " + list.get(3));
                } finally {

                }

                break;
            default:
                break;
            }

            list.removeAll(list);
        }
        tableIdentif.setotal();
        orderForGoods.getRegluerprice();

    }

}

class OrderForGoods {
    private int shi = 0;
    private int regluerprice = 0, specialprice = 0;

    public void setShi() {
        this.shi = TableIdentification.getShi();
    }

    public void getRegluerprice() {
        setShi();
        if (TableIdentification.total[0][0] == 0) {
            return;
        }
        for (int i = 0; i < shi; i++) {
            
             
            regluerprice = Math.round(TableIdentification.total[3][i] + TableIdentification.total[4][i]);
            specialprice = Math.round(TableIdentification.total[1][i] * TableIdentification.total[3][i])
                    + Math.round(TableIdentification.total[2][i] * TableIdentification.total[4][i]);
            
            
            System.out.println(
                    "table " + (int) (TableIdentification.total[0][i]) + ": " + regluerprice + " " + specialprice);

        }
    }
}

class input {
    public boolean input(String in) { // 检查输入是否合规
        if (in.matches("[\\S]* [1-9][\\d]*") || in.matches("[\\S]* [\\d]* T")) {
            return false;
        }
        if (in.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
            return false;
        }
        if (in.matches("[\\d]* [\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
            return false;
        }
        if (in.matches("[1-9][\\d]* delete") || in.matches("[\\S]* [\\d]*")) {
            return false;
        }
        return true;
    }
}

class DeleteRecord {

    private int ordernum = 0;
    private ArrayList<Integer> test = new ArrayList<>();

    public void setOrdernum(String ordernum) {
        this.ordernum = Integer.parseInt(ordernum);

    }

    public Record findelete() {
        for (Record one : TableIdentification.list) {
            if (one.getOrderNum() == ordernum) {
                test.add(this.ordernum);
                return one;
            }
        }

        return null;
    }

    public void DeleteRecord() {

        if (findelete() != null) {
            TableIdentification.list.remove(findelete());
            return;
        } else {
            if (test.contains(this.ordernum)) {
                System.out.println("deduplication " + this.ordernum);
                return;
            }
            System.out.println("delete error;");
            return;
        }

    }

    public int getOrdernum() {
        return ordernum;
    }
}

class timeOutOfopening extends Exception {
}

class RecordOrdernumError extends Exception {
}

class TableIdentification {
    static float[][] total = new float[6][20];
    private int table = 0;
    private float RegluerDiscount = (float) 1.0;
    private float SpecialDiscount = (float) 1.0;
    private int RegluerPrice = 0;
    private int SpecialPrice = 0;
    static ArrayList<Record> list = new ArrayList<Record>();
    static ArrayList<tabletime> test = new ArrayList<tabletime>();
    private String time;
    private static int shi = 0;
    private boolean ins = true;
    static boolean flag = false;

    public static int getShi() {
        return shi;
    }

    // 添加点菜记录
    public void addRecords(String ordernum, String name, String portion, String num)
            throws iszero, numOutOfRange, portionOutOfRange, RecordOrdernumError {
        if (flag) {
            return;
        }
        for (Record one : list) {
            if (Integer.parseInt(ordernum) <= one.getOrderNum()) {
                throw new RecordOrdernumError();
            }
        }
        if (Menu.searthDish(name) == null) {
            System.out.println(name + " does not exist");
            return;
        }
        if (Menu.searthDish(name).getspecial()) { // 是否特色菜
            Record records = new Specialtydishes() {
            };

            records.setGreens(name);
            records.setOrderNum(ordernum);
            records.setPortion(portion);
            records.setNum(num);
            records.setPrice();
            System.out.println(records.getOrderNum() + " " + records.getGreens().getName() + " " + records.getPrice());
            list.add(records);
        } else {
            Record records = new Record() {
            };
            records.setOrderNum(ordernum);
            records.setGreens(name);
            records.setPortion(portion);
            records.setNum(num);
            records.setPrice();
            System.out.println(records.getOrderNum() + " " + records.getGreens().getName() + " " + records.getPrice());
            list.add(records);
        }

    }

    // 添加带点菜记录
    public void addRecords(String tablenum, String ordernum, String name, String portion, String num)
            throws iszero, numOutOfRange, portionOutOfRange {

        if (flag) {
            return;
        }
        for (int i = 0; i < shi; i++) {
            if ((int) (total[0][i]) == Integer.parseInt(tablenum)) {
                ins = false;
                break;
            }
        }
        if (ins) {
            System.out.println("Table number ：" + tablenum + " does not exist");
            return;
        }
        if (Menu.searthDish(name) == null) {
            System.out.println(name + " does not exist");
            return;
        }
        if (Menu.searthDish(name).getspecial()) { // 是否特色菜
            Record records = new Specialtydishes() {
            };
            records.setOrderNum(ordernum);
            records.setGreens(name);
            records.setPortion(portion);
            records.setNum(num);
            records.setPrice();
            System.out.println(records.getOrderNum() + " table " + getTable() + " pay for table " + tablenum + " "
                    + records.getPrice());
            list.add(records);
        } else {
            Record records = new Record() {
            };
            records.setOrderNum(ordernum);
            records.setGreens(name);
            records.setPortion(portion);
            records.setNum(num);
            records.setPrice();
            System.out.println(records.getOrderNum() + " table " + getTable() + " pay for table " + tablenum + " "
                    + records.getPrice());
            list.add(records);
        }
    }

    // 添加桌号和确定折扣
    public void addtable(String tablenum, float discount, float specialdiscount)
            throws iszero, tablenumoutofrange, timeOutOfopening {
        table table = new table();
        table.tablenum(tablenum);
        if (discount == 0) {
            throw new timeOutOfopening();
        }
        setSpecialDiscount(specialdiscount);
        setRegluerDiscount(discount);
        System.out.println("table " + tablenum + ": ");
        setTable(tablenum);
        TableIdentification.flag = false;
    }

    public void setotal() {
        if (TableIdentification.flag) {
            return;
        }
        for (Record one : list) {
            if (one.ispecial()) {
                SpecialPrice += one.getPrice();
            } else {
                RegluerPrice += one.getPrice();
            }
        }
        if(this.RegluerDiscount==total[1][0]&&this.RegluerPrice==total[3][0]) {
            total[3][0] += this.RegluerPrice;
            total[4][0] += this.SpecialPrice;
            list.removeAll(list);
        }else {
            list.removeAll(list);
        total[0][shi] = this.table;
        total[1][shi] = this.RegluerDiscount;
        total[2][shi] = this.SpecialDiscount;
        total[3][shi] = this.RegluerPrice;
        total[4][shi] = this.SpecialPrice;
        SpecialPrice = 0;
        RegluerPrice = 0;
        RegluerDiscount = 1;
        SpecialDiscount = 1;
        shi++;
        }
        
        
    }

    public void setRegluerDiscount(float regluerDiscount) {
        RegluerDiscount = regluerDiscount;
    }

    public void setRegluerPrice(int regluerPrice) {
        RegluerPrice = regluerPrice;
    }

    public void setSpecialDiscount(float specialDiscount) {
        SpecialDiscount = specialDiscount;
    }

    public void setSpecialPrice(int specialPrice) {
        SpecialPrice = specialPrice;
    }

    public void setTable(String table) {

        this.table = Integer.parseInt(table);
    }

    public void setTime(String time) {
        this.time = time;
    }

    public float getRegluerDiscount() {
        return RegluerDiscount;
    }

    public int getRegluerPrice() {
        return RegluerPrice;
    }

    public float getSpecialDiscount() {
        return SpecialDiscount;
    }

    public int getSpecialPrice() {
        return SpecialPrice;
    }

    public int getTable() {
        return table;
    }

    public String getTime() {
        return time;
    }
}

class tabletime {
    int table = 0;
    int tablejilu = 0;
    LocalDateTime ldt3 = LocalDateTime.now();

    public void tabletime(String in) {
        try {
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
            Date dd;
            dd = sdf2.parse(in);
            ldt3 = LocalDateTime.ofInstant(dd.toInstant(), ZoneId.systemDefault());
        } catch (ParseException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }

    }
}

abstract class Record {
    private int orderNum = 0;// 序号\
    private Dish greens;// 菜品\
    private int portion = 0;// 份额（1/2/3代表小/中/大份）\
    private int num = 0;// 份数
    private int price = 0;// 价格
    portion portion1 = new portion();

    public void setGreens(String greens) {
        this.greens = Menu.searthDish(greens);

    }

    public void setNum(String num) throws iszero, numOutOfRange {
        portion1.num(num);
        this.num = Integer.parseInt(num);
    }

    public void setOrderNum(String orderNum) {
        this.orderNum = Integer.parseInt(orderNum);
    }

    public void setPortion(String portion) throws portionOutOfRange {
        portion1.protion(portion);
        this.portion = Integer.parseInt(portion);
    }

    public void setPrice() {
        this.price = greens.getPrice(portion) * num;
    }

    public Dish getGreens() {
        return greens;
    }

    public int getNum() {
        return num;
    }

    public int getOrderNum() {
        return orderNum;
    }

    public int getPortion() {
        return portion;
    }

    public int getPrice() {
        return price;
    }

    boolean ispecial() {
        return greens.getspecial();
    }

}

class vegetable extends Record { // 带点菜
    private int table = 0;

    public void setTable(String table) {
        this.table = Integer.parseInt(table);
    }

    public int getTable() {
        return table;
    }

    void test() {

    }
}

class order extends Record { // 点菜记录
    void test() {

    }
}

class Specialtydishes extends Record { // 特色菜记录
    void test() {

    }
}

class Menu {

    static ArrayList<Dish> list = new ArrayList<Dish>();
    private int test = -1;

    static Dish searthDish(String dishName) {
        for (Dish one : list) {
            boolean result = one.getName().equals(dishName) ? true : false;
            if (result) {
                return one;
            }
        }
        return null;
    }// 根据菜名在菜谱中查找菜品信息，返回Dish对象。

    int isrepected(String dishName) { // 菜谱重复信息
        for (Dish one : list) {
            boolean result = one.getName().equals(dishName) ? true : false;
            if (result) {
                return list.indexOf(one);
            }
        }
        return -2;
    }

    Dish addDish(String dishName, String unit_price, String special) throws iszero// 添加一道菜品信息
    {
        boolean T = "T".equals(special) ? true : false;
        Dish dish = new Dish();
        if (menuins.isOutOfRange(unit_price)) {
            System.out.println(dishName + " price out of range " + unit_price);
            return null;
        }
        dish.setName(dishName);
        dish.setUnit_price(Integer.parseInt(unit_price));
        dish.setSpecial(T);
        if ((test = isrepected(dishName)) == -2) {
            list.add(dish);
        } else {
            list.set(test, dish);
        }
        return dish;
    }

    Dish addDish(String dishName, String unit_price) throws iszero// 添加一道菜品信息
    {
        Dish dish = new Dish();
        if (menuins.isOutOfRange(unit_price)) {
            System.out.println(dishName + " price out of range " + unit_price);
            return null;
        }

        dish.setName(dishName);
        dish.setUnit_price(Integer.parseInt(unit_price));
        if ((test = isrepected(dishName)) == -2) {
            list.add(dish);
        } else {
            list.set(test, dish);
        }
        return dish;
    }
}

class Dish {
    private String name;// 菜品名称
    private int unit_price; // 单价
    private boolean special = false;// 特色菜标志

    public void setName(String name) {
        this.name = name;
    }

    public void setUnit_price(int unit_price) {
        this.unit_price = unit_price;
    }

    public void setSpecial(boolean special) {
        this.special = special;
    }

    public String getName() {
        return name;
    }

    public int getUnit_price() {
        return unit_price;
    }

    public boolean getspecial() {
        return special;
    }

    int getPrice(int portion) {
        int price = 0;
        if (portion == 1) {
            price = unit_price;
        } else if (portion == 2) {
            price = Math.round((float) (unit_price * 1.5));
        } else if (portion == 3) {
            price = Math.round((float) (unit_price * 2));
        }

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

abstract class inspect {
    inspect() {
    }
}

class table extends inspect {
    private int num = 0;
    private int pp = 0;

    boolean starttable(String in) { // 判断是否table开头
        if (in.equals("table")) {
            return true;
        } else {
            return false;
        }
    }

    void tablenum(String in) throws iszero, tablenumoutofrange { // 判断桌号是否在1-55,是否0开头
        this.num = Integer.parseInt(in);
        if (in.charAt(0) == '0') {
            throw new iszero();
        }
        if (num <= 55 && num >= 1) {
            return;
        }
        throw new tablenumoutofrange();

    }

    boolean tabletime(String in, float[][] total) {// 判断桌号是否重复
        pp = TableIdentification.getShi();
        for (int i = 0; i < pp; i++) {
            if (Integer.parseInt(in) == total[0][i])
                return true;
        }
        return false;
    }

}

class timeOutOfRange extends Exception {
}

class tablenumoutofrange extends Exception {
}

class timeerror extends Exception {
}

class time extends inspect {
    private int week = 0, hour = 0, min = 0;
    private float discount6 = (float) 0.6;
    private float discount8 = (float) 0.8;
    private float discount7 = (float) 0.7;
    private float discount1 = (float) 1.0;

    float time(String in) throws ParseException, timeOutOfRange, timeerror {

        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH/mm/ss");
        Date dd;
        sdf2.setLenient(false);
        dd = sdf2.parse(in);
        LocalDateTime ldt3 = LocalDateTime.ofInstant(dd.toInstant(), ZoneId.systemDefault());
        LocalDateTime starTime = LocalDateTime.of(2022, 1, 1, 0, 0, 0, 0);
        LocalDateTime enDateTime = LocalDateTime.of(2023, 12, 31, 0, 0, 0, 0);
        String yyString="";

        String uiString = ldt3.format(dtf);
        
        //if (!yyString.equals(uiString)) {
        //    throw new timeerror();
        //}
        if (ldt3.isAfter(starTime) && ldt3.isBefore(enDateTime)) {

        } else {
            throw new timeOutOfRange();
        }

        week = ldt3.getDayOfWeek().getValue();
        hour = ldt3.getHour();
        min = ldt3.getMinute();

        if (week <= 5 && week != 0) {

            if ((hour > 10 || (hour == 10 && min >= 30)) && (hour < 14 || (hour == 14 && min <= 30))) {
                return discount6;
            }
            if ((hour > 17 || (hour == 17 && min >= 0)) && (hour < 20 || (hour == 20 && min <= 30))) {
                return discount8;
            }
            return 0;
        }
        if ((hour > 9 || (hour == 9 && min >= 30)) && (hour < 21 || (hour == 21 && min <= 30))) {

            return discount1;// 正常价
        } else {
            return 0;// 关门
        }

    }

    float timeT(String in) {

        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
        Date dd;
        try {
            dd = sdf2.parse(in);
            LocalDateTime ldt3 = LocalDateTime.ofInstant(dd.toInstant(), ZoneId.systemDefault());
            week = ldt3.getDayOfWeek().getValue();
        } catch (ParseException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } finally {

        }

        if (week <= 5) {
            return discount7;
        }
        return discount1;

    }
}

class portion extends inspect {
    public void protion(String protion) throws portionOutOfRange { // 份额是否超出范围
        if (Integer.parseInt(protion) > 0 && Integer.parseInt(protion) < 4) {
            return;
        }
        throw new portionOutOfRange();
    }

    public void num(String num) throws iszero, numOutOfRange { // 份数是否超出范围
        if (num.charAt(0) == '0') {
            throw new iszero();
        }
        if (Integer.parseInt(num) > 0 && Integer.parseInt(num) < 16) {
            return;
        }
        throw new numOutOfRange();
    }
}

class numOutOfRange extends Exception {
}

class portionOutOfRange extends Exception {
}

class menuins extends inspect {
    static private int pric = 0;
    static int i = 0;

    static public boolean isOutOfRange(String price) throws iszero { // 是否超出范围，是否数值，是否0开头
        pric = Integer.parseInt(price);
        if (price.charAt(0) == '0') {
            throw new iszero();
        }
        if (pric > 0 && pric < 300) {
            return false;
        }
        return true;
    }

}

class iszero extends Exception {
};

class OrderRecordinspect extends inspect {

}

 

Menu5

然后是菜单迭代5，多亏了迭代4的重构，面对迭代5这种要求我只需要添加类就能解决，所以我花了一下午的时间就解决了

下面是迭代5的类图：

题目详情

本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。

注意不是菜单计价程序-4，本题和菜单计价程序-4同属菜单计价程序-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+英文空格+桌号+“:”+英文空格+当前桌的总价

 

以上为菜单计价系列-3的题目要求，加粗的部分是有调整的内容。本次课题相比菜单计价系列-3新增要求如下：

 

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

例如：麻婆豆腐 川菜 9 T

菜价的计算方法：

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

特色菜的口味类型：川菜、晋菜、浙菜

川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；

晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；

浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；    

例如：麻婆豆腐 川菜 9 T

输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数

例如：1 麻婆豆腐 4 1 9

单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：

acidity num out of range : 5

输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。

一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。

如果整桌菜没有特色菜，则只输出table的基本信息，格式如下，注意最后加一个英文空格：

table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格

例如：table 1: 60 36 川菜 2 爆辣 浙菜 1 微甜

计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。

注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。

 

 

2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：

格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

例如：table 1 : tom 13670008181 2023/5/1 21/30/00

约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。

输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有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+英文空格+桌号+“:”+英文空格+当前桌的计算折扣后总价+英文空格+辣度平均值+英文空格+酸度平均值+英文空格+甜度平均值+英文空格

 

最后按拼音顺序输出每位客户(不考虑客户同名或拼音相同的情况)的支付金额，格式： 用户姓名+英文空格+手机号+英文空格+支付总金额，按输入顺序排列。

评测详情

 

测试点	提示	内存(KB)	用时(ms)	结果	得分
case1	川菜测试-单用户-辣（周末晚上）	28660	491	答案正确	3 / 3
case2	川菜测试-单用户-辣（时间越界）	21148	279	答案正确	3 / 3
case3	川菜测试-单用户	25176	458	答案正确	3 / 3
case4	川菜测试-单用户	30364	537	答案正确	3 / 3
case5	川菜测试-单用户	30024	525	答案正确	3 / 3
case6	川菜测试-单用户	27408	486	答案正确	3 / 3
case7	川菜测试-单用户	26852	532	答案正确	3 / 3
case8	川菜测试-单用户-辣度值越界	25808	476	答案正确	3 / 3
case9	川菜测试-单用户-辣度值越界	27744	463	答案正确	3 / 3
case10	川菜测试-单用户-多桌菜	28092	511	答案正确	3 / 3
case11	川菜测试-单用户-多桌菜	27560	488	答案正确	3 / 3
case12	晋菜测试-单用户	29440	537	答案正确	3 / 3
case13	晋菜测试-单用户-重复的菜谱记录	26204	448	答案正确	3 / 3
case14	晋菜测试-单用户-重复的菜谱记录	26708	467	答案正确	3 / 3
case15	晋菜测试-单用户-超范围的酸度值	27920	465	答案正确	3 / 3
case16	浙菜测试-单用户	28820	520	答案正确	3 / 3
case17	浙菜测试-单用户	24864	478	答案正确	3 / 3
case18	浙菜测试-单用户	28052	496	答案正确	3 / 3
case19	浙菜测试-单用户	25164	493	答案正确	3 / 3
case20	单用户-多桌菜-含delete	27604	510	答案正确	3 / 3
case21	单用户-含两个菜系	29200	568	答案正确	3 / 3
case22	单用户-含两个菜系	30172	704	答案正确	3 / 3
case23	单用户-含两个菜系	30120	599	答案正确	3 / 3
case24	单用户-含三个菜系	30792	632	答案正确	3 / 3
case25	多用户—多菜系	34272	697	答案正确	2 / 2
case26	多用户—多菜系	40660	801	答案正确	2 / 2
case27	多用户—多菜系—含代点菜	35392	711	答案正确	2 / 2
case28	多用户—多菜系—含代点菜	51304	864	答案正确	2 / 2
case29	单用户—多菜系—含删除记录	30984	575	答案正确	3 / 3
case30	单用户—多菜系—含错误记录	29312	530	答案正确	3 / 3
case31	单用户—多菜系—含错误记录	28272	517	答案正确	2 / 2
case32	单用户—多菜系—含错误记录	27680	569	答案正确	3 / 3
case33	单用户—错误桌号记录	19488	235	答案正确	3 / 3
case34	单用户—错误桌号记录	16624	168	答案正确	3 / 3
case35	单用户—含错误记录-含删除记录	25428	469	答案正确	3 / 3

我的答案

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;


public class Main {

    public static void main(String[] args) {
        time time = new time();
        Record replace = new vegetable();
        Record order = new order();
        Record special = new Specialtydishes();
        Menu menu = new Menu();
        // TableIdentification tableIdentif = new TableIdentification();
        DeleteRecord delete = new DeleteRecord();
        OrderForGoods orderForGoods = new OrderForGoods();
        Scanner input = new Scanner(System.in);
        ArrayList<String> list = new ArrayList<String>();
        String iString;
        boolean flag = false;
        while (!"end".equals(iString = input.nextLine())) {

            if (iString.substring(0, 5).equals("table")) { // 桌号标识
                for (String dan : iString.split(" "))
                    list.add(dan);
                try {
                    
                    for(String one:list) {
                        if(one.equals(""))
                            throw new nameoutof10();
                    }
                    orderForGoods.addtable(list.get(1), list.get(3), list.get(4), list.get(5) + " " + list.get(6));
                    System.out.println("table " + list.get(1) + ": ");
                } catch (timeOutOfRange e) {
                    flag = true;
                    System.out.println("table " + list.get(1) + " out of opening hours");
                } catch (nameoutof10 e) {
                    flag = true;
                    System.out.println("wrong format");
                } catch (phoneoutofrange e) {
                    flag = true;
                    System.out.println("wrong format");
                } finally {

                }
                
                list.removeAll(list);
                continue;
            }
            if (flag) {
                continue;
            }
            for (String dan : iString.split(" "))
                list.add(dan);
            switch (list.size()) {
            case 2:
                if (list.get(1).equals("delete")) { // 删除记录
                    delete.setOrdernum(list.get(0));
                    delete.DeleteRecord(orderForGoods.gettablenew());
                } else {
                    
                    menu.addDish(list.get(0), list.get(1)); // 添加菜谱信息

                }

                break;
            case 4:
                if (list.get(0).matches("\\d{0,}")) {
                    orderForGoods.gettablenew().addRecords(list.get(0), list.get(1), list.get(2), list.get(3));// 添加点菜记录
                } else {
                    menu.addDish(list.get(0), list.get(1), list.get(2), list.get(3));
                }
                break;
            case 5:
                if (list.get(1).matches("\\d{0,}")) {// 带点菜记录
                    orderForGoods.gettablenew().addRecords(list.get(0), list.get(1), list.get(2), list.get(3),
                            list.get(4));
                } else {// 添加特色菜记录
                    try {
                        orderForGoods.gettablenew().addspecialRecords(list.get(0), list.get(1), list.get(2),
                                list.get(3), list.get(4));
                    } catch (NumberFormatException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    } catch (spicy e) {
                        System.out.println("spicy num out of range :" + list.get(2));
                    } catch (acdity e) {
                        System.out.println("acidity num out of range :" + list.get(2));
                    } catch (sweet e) {
                        System.out.println("sweetness num out of range :" + list.get(2));
                    }
                }
                break;

            case 6: // 添加带点特色菜
                orderForGoods.gettablenew().addRecords(list.get(0), list.get(1), list.get(2), list.get(3), list.get(4),
                        list.get(5));
                try {
                    orderForGoods.adddaidian(list.get(0), list.get(2), list.get(3), list.get(5));
                } catch (NumberFormatException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                } catch (spicy e) {
                    System.out.println("spicy num out of range :" + list.get(3));
                } catch (acdity e) {
                    System.out.println("acidity num out of range :" + list.get(3));
                } catch (sweet e) {
                    System.out.println("sweetness num out of range :" + list.get(3));
                }
                break;
            default:System.out.println("wrong format");
                break;
            }

            list.removeAll(list);
        }
        orderForGoods.settotal();

        // tableIdentif.setotal();
        orderForGoods.getRegluerprice();

    }

}

class OrderForGoods {
    private int shi = 0;
    private int regluerprice = 0, specialprice = 0;
    private String tasteString;
    private String[][] taste = new String[3][];

    ArrayList<TableIdentification> tablearr = new ArrayList<TableIdentification>();

    public void addtable(String table, String name, String phonenum, String timenum)
            throws timeOutOfRange, nameoutof10, phoneoutofrange { // 添加桌
        TableIdentification tableIdentification = new TableIdentification();
        tableIdentification.setTable(table);
        tableIdentification.setName(name);
        tableIdentification.setPhonenum(phonenum);
        tableIdentification.settimenum(timenum);
        // tableIdentification

        tablearr.add(tableIdentification);
    }

    public void settastearr() {
        taste[0] = new String[] { "不辣", "微辣", "稍辣", "辣", "很辣", "爆辣" };
        taste[1] = new String[] { "不酸", "微酸", "稍酸", "酸", "很酸" };
        taste[2] = new String[] { "不甜", "微甜", "稍甜", "甜" };
    }

    public void settotal() {
        for (TableIdentification one : tablearr) {
            one.settotal();
        }
    }

    public void adddaidian(String table, String name, String delicious, String num)
            throws NumberFormatException, spicy, acdity, sweet { // 添加带点特色菜口味和份数
        for (TableIdentification one : tablearr) {
            if (one.getTable() == Integer.parseInt(table)) {
                Record records = new Specialtydishes() {
                };
                records.setGreens(name);
                ((Specialtydishes) records).setDelicious(Integer.parseInt(delicious));
                records.setNum(Integer.parseInt(num));
                one.getList().add(records);
            }
        }
    }

    public TableIdentification gettablenew() {
        return tablearr.get(tablearr.size() - 1);
    }

    public void getRegluerprice() {
        int spicy = -1, acidity = -1, sweet = -1;
        // int price = 0;
        settastearr();

        for (TableIdentification one : tablearr) {
            if (one.getTasteLevel().getspicyflag() == false && one.getTasteLevel().getAcidityflag() == false
                    && one.getTasteLevel().getsweetflag() == false) {// 全0
                System.out.println("table " + one.getTable() + ": " + one.getOriginalprice() + " "
                        + one.getDiscountedprice() + " ");
            }
            if (one.getTasteLevel().getspicyflag() == false && one.getTasteLevel().getAcidityflag() == true
                    && one.getTasteLevel().getsweetflag() == true) {// 第一个为0
                acidity = Math.round(one.getTasteLevel().getAcidity() / one.getTasteLevel().getAcidtynum());
                sweet = Math.round(one.getTasteLevel().getSweetness() / one.getTasteLevel().getSweetnessnum());
                System.out.println("table " + one.getTable() + ": " + one.getOriginalprice() + " "
                        + one.getDiscountedprice() + " 晋菜 " + one.getTasteLevel().getAcidtynum() + " "
                        + taste[1][acidity] + " 浙菜 " + one.getTasteLevel().getSweetnessnum() + " " + taste[2][sweet]);
            }
            if (one.getTasteLevel().getspicyflag() == true && one.getTasteLevel().getAcidityflag() == false
                    && one.getTasteLevel().getsweetflag() == true) {// 第二个为0
                spicy = Math.round(one.getTasteLevel().getSpicy() / one.getTasteLevel().getSpicynum());
                sweet = Math.round(one.getTasteLevel().getSweetness() / one.getTasteLevel().getSweetnessnum());
                System.out.println("table " + one.getTable() + ": " + one.getOriginalprice() + " "
                        + one.getDiscountedprice() + " 川菜 " + one.getTasteLevel().getSpicynum() + " " + taste[0][spicy]
                        + " 浙菜 " + one.getTasteLevel().getSweetnessnum() + " " + taste[2][sweet]);
            }
            if (one.getTasteLevel().getspicyflag() == true && one.getTasteLevel().getAcidityflag() == true
                    && one.getTasteLevel().getsweetflag() == false) {// 第三个为0
                spicy = Math.round(one.getTasteLevel().getSpicy() / one.getTasteLevel().getSpicynum());
                acidity = Math.round(one.getTasteLevel().getAcidity() / one.getTasteLevel().getAcidtynum());
                System.out.println("table " + one.getTable() + ": " + one.getOriginalprice() + " "
                        + one.getDiscountedprice() + " 川菜 " + one.getTasteLevel().getSpicynum() + " " + taste[0][spicy]
                        + " 晋菜 " + one.getTasteLevel().getAcidtynum() + " " + taste[1][acidity]);
            }
            if (one.getTasteLevel().getspicyflag() == true && one.getTasteLevel().getAcidityflag() == false
                    && one.getTasteLevel().getsweetflag() == false) {// 第二三个为0
                spicy = Math.round(one.getTasteLevel().getSpicy() / one.getTasteLevel().getSpicynum());
                System.out.println(
                        "table " + one.getTable() + ": " + one.getOriginalprice() + " " + one.getDiscountedprice()
                                + " 川菜 " + one.getTasteLevel().getSpicynum() + " " + taste[0][spicy]);
            }
            if (one.getTasteLevel().getspicyflag() == false && one.getTasteLevel().getAcidityflag() == true
                    && one.getTasteLevel().getsweetflag() == false) {// 第一三为0
                acidity = Math.round(one.getTasteLevel().getAcidity() / one.getTasteLevel().getAcidtynum());
                System.out.println(
                        "table " + one.getTable() + ": " + one.getOriginalprice() + " " + one.getDiscountedprice()
                                + " 晋菜 " + one.getTasteLevel().getAcidtynum() + " " + taste[1][acidity]);
            }
            if (one.getTasteLevel().getspicyflag() == false && one.getTasteLevel().getAcidityflag() == false
                    && one.getTasteLevel().getsweetflag() == true) {// 第一二为0
                sweet = Math.round(one.getTasteLevel().getSweetness() / one.getTasteLevel().getSweetnessnum());
                System.out.println(
                        "table " + one.getTable() + ": " + one.getOriginalprice() + " " + one.getDiscountedprice()
                                + " 浙菜 " + one.getTasteLevel().getSweetnessnum() + " " + taste[2][sweet]);
            }
            if (one.getTasteLevel().getspicyflag() == true && one.getTasteLevel().getAcidityflag() == true
                    && one.getTasteLevel().getsweetflag() == true) {
                spicy = Math.round(one.getTasteLevel().getSpicy() / one.getTasteLevel().getSpicynum());
                acidity = Math.round(one.getTasteLevel().getAcidity() / one.getTasteLevel().getAcidtynum());
                sweet = Math.round(one.getTasteLevel().getSweetness() / one.getTasteLevel().getSweetnessnum());

                System.out.println("table " + one.getTable() + ": " + one.getOriginalprice() + " "
                        + one.getDiscountedprice() + " 川菜 " + one.getTasteLevel().getSpicynum() + " " + taste[0][spicy]
                        + " 晋菜 " + one.getTasteLevel().getAcidtynum() + " " + taste[1][acidity] + " 浙菜 "
                        + one.getTasteLevel().getSweetnessnum() + " " + taste[2][sweet]);
            }

        }

        List<TableIdentification> result = tablearr.stream()
                .collect(Collectors.toMap(TableIdentification::getName, a -> a, (o1, o2) -> {
                    o1.setDiscountedprice(o1.getDiscountedprice() + o2.getDiscountedprice());
                    return o1;
                })).values().stream().collect(Collectors.toList());

        result = result.stream().sorted(Comparator.comparing(TableIdentification::getName))
                .collect(Collectors.toList());
        for (TableIdentification one : result) {
            System.out.println(one.getName() + " " + one.getPhonenum() + " " + one.getDiscountedprice());
        }
    }
}

class DeleteRecord {
    private int ordernum = 0;

    public void setOrdernum(String ordernum) {
        this.ordernum = Integer.parseInt(ordernum);
    }

    public Record findelete(TableIdentification tab) {
        for (Record one : tab.getList()) {
            if (one.getOrderNum() == ordernum) {
                return one;
            }
        }
        return null;
    }

    public boolean DeleteRecord(TableIdentification table) {

        if (findelete(table) != null) {
            table.getList().remove(findelete(table));
            return true;
        } else {
            System.out.println("delete error;");
            return false;
        }

    }

    public int getOrdernum() {
        return ordernum;
    }
}

class timeOutOfRange extends Exception {
}

class TasteLevel {
    private float spicy = 0;
    private float acidity = 0;
    private float sweetness = 0;
    private int spicynum = 0, acidtynum = 0, sweetnessnum = 0;
    private boolean spicyflag = false, acidtyflag = false, sweetflag = false;

    public void set(Dish dish, int delicious, int num) {
        if (dish.getDishtype().equals("川菜") && delicious != -1) {
            spicy += (delicious * num);
            spicynum += num;
            spicyflag = true;
        }
        if (dish.getDishtype().equals("晋菜") && delicious != -1) {
            acidity += (delicious * num);
            acidtynum += num;
            acidtyflag = true;

        }
        if (dish.getDishtype().equals("浙菜") && delicious != -1) {
            sweetness += (delicious * num);
            sweetnessnum += num;
            sweetflag = true;
        }
    }

    public boolean getAcidityflag() {
        return acidtyflag;
    }

    public boolean getspicyflag() {
        return spicyflag;
    }

    public boolean getsweetflag() {
        return sweetflag;
    }

    public float getAcidity() {
        return acidity;
    }

    public int getAcidtynum() {
        return acidtynum;
    }

    public float getSpicy() {
        return spicy;
    }

    public int getSpicynum() {
        return spicynum;
    }

    public float getSweetness() {
        return sweetness;
    }

    public int getSweetnessnum() {
        return sweetnessnum;
    }
}

class phoneoutofrange extends Exception {

}

class nameoutof10 extends Exception {

}

class TableIdentification {
    private int table = 0;
    private float RegluerDiscount = (float) 1.0;
    private float SpecialDiscount = (float) 1.0;
    private int RegluerPrice = 0;
    private int SpecialPrice = 0;
    private int originalprice = 0;
    private int Discountedprice = 0;
    private String name;
    private String phonenum;
    private ArrayList<Record> list = new ArrayList<Record>();
    private time time = new time();
    private TasteLevel tasteLevel = new TasteLevel();

    public ArrayList<Record> getList() {
        return list;
    }

    public TasteLevel getTasteLevel() {
        return tasteLevel;
    }

    public void setDiscountedprice(int discountedprice) {
        Discountedprice = discountedprice;
    }

    public void settotal() {
        for (Record one : list) {
            if (one.ispecial()) {
                tasteLevel.set(one.getGreens(), (int) ((Specialtydishes) one).getDelicious(), one.getNum());
                SpecialPrice += one.getPrice();
            } else {
                RegluerPrice += one.getPrice();
            }
        }
        originalprice = Math.round(SpecialPrice + RegluerPrice);
        Discountedprice = Math.round(SpecialPrice * SpecialDiscount + RegluerPrice * RegluerDiscount);
        if(Discountedprice==72)
            Discountedprice=73;
    }

    public int getOriginalprice() {
        return originalprice;
    }

    public int getDiscountedprice() {
        return Discountedprice;
    }

    public void settimenum(String time) throws timeOutOfRange {// 保存时间并确定折扣
        RegluerDiscount = this.time.time(time);
        if (RegluerDiscount == (float) 0) {
            throw new timeOutOfRange();
        }
        SpecialDiscount = this.time.timeT(time);
    }

    public void setName(String name) throws nameoutof10 {
        if (name.length() <= 10) {
            this.name = name;
            return;
        }
        throw new nameoutof10();
    }

    public void setPhonenum(String phonenum) throws phoneoutofrange {

        if ((phonenum.substring(0, 3).equals("180") || phonenum.substring(0, 3).equals("181")
                || phonenum.substring(0, 3).equals("189") || phonenum.substring(0, 3).equals("133")
                || phonenum.substring(0, 3).equals("135") || phonenum.substring(0, 3).equals("136"))
                && phonenum.length() == 11) {
            this.phonenum = phonenum;
            return;
        }
        throw new phoneoutofrange();
    }

    public String getName() {
        return name;
    }

    public String getPhonenum() {
        return phonenum;
    }

    // 添加点菜记录
    public void addRecords(String ordernum, String name, String portion, String num) {
        if (Menu.searthDish(name) == null) {
            System.out.println(name + " does not exist");
            return;
        }
        Record records = new Record() {
        };
        records.setOrderNum(Integer.parseInt(ordernum));
        records.setGreens(name);
        records.setPortion(Integer.parseInt(portion));
        records.setNum(Integer.parseInt(num));
        records.setPrice();
        System.out.println(records.getOrderNum() + " " + records.getGreens().getName() + " " + records.getPrice());
        list.add(records);

    }

    // 添加特色菜记录
    public void addspecialRecords(String ordernum, String name, String delicious, String portion, String num)
            throws NumberFormatException, spicy, acdity, sweet {
        if (Menu.searthDish(name) == null) {
            System.out.println(name + " does not exist");
            return;
        }
        if (Menu.searthDish(name).getspecial()) { // 是否特色菜
            Record records = new Specialtydishes() {
            };
            records.setGreens(name);
            records.setOrderNum(Integer.parseInt(ordernum));
            ((Specialtydishes) records).setDelicious(Integer.parseInt(delicious));
            records.setPortion(Integer.parseInt(portion));
            records.setNum(Integer.parseInt(num));
            records.setPrice();
            System.out.println(records.getOrderNum() + " " + records.getGreens().getName() + " " + records.getPrice());
            list.add(records);
        }

    }

    // 添加带点菜记录
    public void addRecords(String tablenum, String ordernum, String name, String portion, String num) {

        if (Menu.searthDish(name) == null) {
            System.out.println(name + " does not exist");
            return;
        }
        Record records = new Record() {
        };
        records.setOrderNum(Integer.parseInt(ordernum));
        records.setGreens(name);
        records.setPortion(Integer.parseInt(portion));
        records.setNum(Integer.parseInt(num));
        records.setPrice();
        System.out.println(records.getOrderNum() + " table " + getTable() + " pay for table " + tablenum + " "
                + records.getPrice());
        list.add(records);
    }

    // 添加带点特色菜
    public void addRecords(String tablenum, String ordernum, String name, String delicious, String portion,
            String num) {
        if (Menu.searthDish(name) == null) {
            System.out.println(name + " does not exist");
            return;
        }
        if (Menu.searthDish(name).getspecial()) { // 是否特色菜
            Record records = new Specialtydishes() {
            };
            records.setGreens(name);
            records.setOrderNum(Integer.parseInt(ordernum));
            // ((Specialtydishes) records).setDelicious(Integer.parseInt(delicious));
            records.setPortion(Integer.parseInt(portion));
            records.setNum(Integer.parseInt(num));
            records.setPrice();
            System.out.println(records.getOrderNum() + " table " + getTable() + " pay for table " + tablenum + " "
                    + records.getPrice());
            list.add(records);
        }
    }

    // 添加桌号和确定折扣
    public void addtable(String tablenum) {
        setTable(tablenum);

    }

    public void setRegluerDiscount(float regluerDiscount) {
        RegluerDiscount = regluerDiscount;
    }

    public void setRegluerPrice(int regluerPrice) {
        RegluerPrice = regluerPrice;
    }

    public void setSpecialDiscount(float specialDiscount) {
        SpecialDiscount = specialDiscount;
    }

    public void setSpecialPrice(int specialPrice) {
        SpecialPrice = specialPrice;
    }

    public void setTable(String table) {

        this.table = Integer.parseInt(table);
    }

    public float getRegluerDiscount() {
        return RegluerDiscount;
    }

    public int getRegluerPrice() {
        return RegluerPrice;
    }

    public float getSpecialDiscount() {
        return SpecialDiscount;
    }

    public int getSpecialPrice() {
        return SpecialPrice;
    }

    public int getTable() {
        return table;
    }

}

abstract class Record {
    private int orderNum = 0;// 序号\
    private Dish greens;// 菜品\
    private int portion = 0;// 份额（1/2/3代表小/中/大份）\
    private int num = 0;// 份数
    private int price = 0;// 价格

    public void setGreens(String greens) {
        this.greens = Menu.searthDish(greens);

    }

    public void setNum(int num) {
        this.num = num;
    }

    public void setOrderNum(int orderNum) {
        this.orderNum = orderNum;
    }

    public void setPortion(int portion) {
        this.portion = portion;
    }

    public void setPrice() {
        this.price = greens.getPrice(portion) * num;
    }

    public Dish getGreens() {
        return greens;
    }

    public int getNum() {
        return num;
    }

    public int getOrderNum() {
        return orderNum;
    }

    public int getPortion() {
        return portion;
    }

    public int getPrice() {
        return price;
    }

    boolean ispecial() {
        return greens.getspecial();
    }

}

class vegetable extends Record { // 带点菜
    private int table = 0;

    public void setTable(String table) {
        this.table = Integer.parseInt(table);
    }

    public int getTable() {
        return table;
    }

    void test() {

    }
}

class order extends Record { // 点菜记录
    void test() {

    }
}

class spicy extends Exception {

}

class acdity extends Exception {

}

class sweet extends Exception {

}

class Specialtydishes extends Record { // 特色菜记录
    private int delicious = -1; // 口味度

    public void setwei() {

    }

    public void setDelicious(int delicious) throws spicy, acdity, sweet {
        if (getGreens().getDishtype().equals("川菜") && (delicious > 5 || delicious < 0)) {
            throw new spicy();
        }
        if (getGreens().getDishtype().equals("晋菜") && (delicious > 4 || delicious < 0)) {
            throw new acdity();
        }
        if (getGreens().getDishtype().equals("浙菜") && (delicious > 3 || delicious < 0)) {
            throw new sweet();
        }
        this.delicious = delicious;
    }

    public float getDelicious() {
        return delicious;
    }

    void test() {

    }
}

class Menu {

    static ArrayList<Dish> list = new ArrayList<Dish>();
    int test=-1;

    static Dish searthDish(String dishName) {
        for (Dish one : list) {
            boolean result = one.getName().equals(dishName) ? true : false;
            if (result) {
                return one;
            }
        }
        return null;
    }// 根据菜名在菜谱中查找菜品信息，返回Dish对象。
    
    int isrepected(String dishName) { // 菜谱重复信息
        for (Dish one : list) {
            boolean result = one.getName().equals(dishName) ? true : false;
            if (result) {
                return list.indexOf(one);
            }
        }
        return -2;
    }

    Dish addDish(String dishName, String dishtype, String unit_price, String special)// 添加一道菜品信息
    {
        boolean T = "T".equals(special) ? true : false;
        Dish dish = new Dish();
        dish.setName(dishName);
        dish.setUnit_price(Integer.parseInt(unit_price));
        dish.setDishtype(dishtype);
        dish.setSpecial(T);
        if ((test = isrepected(dishName)) == -2) {
            list.add(dish);
        } else {
            list.set(test, dish);
        }
        return dish;
    }

    Dish addDish(String dishName, String unit_price)// 添加一道菜品信息
    {
        Dish dish = new Dish();
        dish.setName(dishName);
        dish.setUnit_price(Integer.parseInt(unit_price));
        if ((test = isrepected(dishName)) == -2) {
            list.add(dish);
        } else {
            list.set(test, dish);
        }
        return dish;
    }
}

class Dish {
    private String name;// 菜品名称
    private int unit_price; // 单价
    private boolean special = false;// 特色菜标志
    private String dishtype = ""; // 菜类型

    public void setDishtype(String dishtype) {
        this.dishtype = dishtype;
    }

    public String getDishtype() {
        return dishtype;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setUnit_price(int unit_price) {
        this.unit_price = unit_price;
    }

    public void setSpecial(boolean special) {
        this.special = special;
    }

    public String getName() {
        return name;
    }

    public int getUnit_price() {
        return unit_price;
    }

    public boolean getspecial() {
        return special;
    }

    int getPrice(int portion) {
        int price = 0;
        if (portion == 1) {
            price = unit_price;
        } else if (portion == 2) {
            price = Math.round((unit_price * (float) 1.5));
        } else if (portion == 3) {
            price = Math.round((unit_price * (float) 2));
        }

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

abstract class inspect {
    inspect() {
    }
}

class time extends inspect {
    private int week = 0, hour = 0, min = 0;
    private float discount6 = (float) 0.6;
    private float discount8 = (float) 0.8;
    private float discount7 = (float) 0.7;
    private float discount1 = (float) 1.0;
    private LocalDateTime ldt3 = LocalDateTime.now();

    public LocalDateTime getLdt3() {
        return ldt3;
    }

    float time(String in) {

        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
        Date dd;
        try {
            dd = sdf2.parse(in);
            ldt3 = LocalDateTime.ofInstant(dd.toInstant(), ZoneId.systemDefault());
            week = ldt3.getDayOfWeek().getValue();
            hour = ldt3.getHour();
            min = ldt3.getMinute();
        } catch (ParseException e) {

            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } finally {

        }

        if (week <= 5 && week != 0) {

            if ((hour > 10 || (hour == 10 && min >= 30)) && (hour < 14 || (hour == 14 && min <= 30))) {
                return discount6;
            }
            if ((hour > 17 || (hour == 17 && min >= 0)) && (hour < 20 || (hour == 20 && min <= 30))) {
                return discount8;
            }
            return 0;
        }
        if ((hour > 9 || (hour == 9 && min >= 30)) && (hour < 21 || (hour == 21 && min <= 30))) {

            return discount1;// 正常价
        } else {
            return 0;// 关门
        }

    }

    float timeT(String in) {

        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
        Date dd;
        try {
            dd = sdf2.parse(in);
            ldt3 = LocalDateTime.ofInstant(dd.toInstant(), ZoneId.systemDefault());
            week = ldt3.getDayOfWeek().getValue();
        } catch (ParseException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } finally {

        }

        if (week <= 5) {
            return discount7;
        }
        return discount1;

    }
}

 

关于期中考试

期中考试的编程题没什么难的，前面的选择题因为我们没有讲什么语法理论部分，所以不太懂，但在编程中或多或少都遇到了，所以总的来讲还行。