加载中...

第一次java博客作业

前言：

JAVA是这一学期新学的一门课程， 是目前市面上比较火的一种编程语言，相比于大一上学期学的C语言来说，我认为JAVA的难度要远远大于C语言，其中就包括一些函数之多和类之广泛的原因，正是因为它比较难，所以才得更加好好学习，去努力把他学好，接下来，我将会从这三次题目所涉及的知识点，难度以及题量还有我对这三次作业的看法这四个方面展开，有针对的展开一次总结性blog！

1.题量：

  • (1).第一次大作业：

对于第一次大作业而言，第一次大作业应该是这三次大作业里面题量最多的有九道，但是同时又是最简单的一次，因为刚开始可能老师想让我们练习一下JAVA的基本语言和语法的使用规则，所以比较简单。

  • (2).第二次大作业：

第二次大作业中，一共有四道题题量，相比于上一次减少了很多，但是难度却增加了不少，因为第一题和第二题是一个关于点菜系统的系列题，题目比较长，过程比较繁琐难度上来了。

  • (3).第三次大作业：

第三次大作业，一共有七道题，其中第一道题是最难的一道题目，最长的一道题量中等

2.难度：

  • (1).第一次大作业：

第一次大作业的难度，我认为不太难，比较简单，除了在那个求古巴比伦法典那个题，还有那个最后的判断三角形中直角三角形的判断，它不能用等于号来判断，应该是小于等于一个小数才行，这两个题稍微卡了一会。

  • (2).第二次大作业：

在第二次大作业中，第一次看到点菜程序这两道题的时候，心里面凉了一截，心里面就会自主的去排斥这两道题，感觉他会很难，但是随着时间截止，又不得不去做，于是我便开始尝试了做做这几道题，难度我感觉是比较大的。

  • (3).第三次大作业：

第三次大作业的第一题，那么长的一大串，我感觉其实真的是不容易的，我光做第一题就做了整整的一天多，代码写完了之后，还有很多的bug又调试了多半天，最后基本上是花了两天多才把它写完，我感觉第一题的难度是比较大的，其余的那几道题也很有难度，像那个单词的排序，我感觉也不容易。

3.知识点：

  • (1).第一次大作业：

我认为刚开始学到的知识点还挺多的代码如下

  for(i=0;i<s.length();i++){
           if(s.charAt(i)=='0'||s.charAt(i)=='1')
             a+=s.charAt(i);
           else if(s.charAt(i)=='-'&&s.charAt(i+1)=='1'){
               System.out.print(a);
               return ;}

       }

/s.char(i)方法的使用，提取一个字符

String xueyuan=s.substring(2,4);
           if(xueyuan.equals("01"))
               xueyuan="材料学院";
           else if(xueyuan.equals("02"))
                 xueyuan="机械学院";
           else if(xueyuan.equals("03"))
               xueyuan="外语学院";
           else if(xueyuan.equals("20"))
               xueyuan="软件学院";
           else{
               System.out.print("Wrong Format");

/equals方法和substring方法的使用，可以指定提取一段字符串的某几个

  • (2).第二次大作业：

我在这次大作业中学到了数组的开辟与创建
代码如下
public Dish[] dishs=new Dish[20];
这步操作是对Dish数组空间的开辟
dishs[f]=new Dish(dishName,unit_price);
这个操作是new一个Dish类的对象。
我还学习到了对一个字符串类型的s将其以' '分割并保存到一个字符串数组当中去，代码如下

Scanner scanner=new Scanner;
String s=scanenr.nextLine();
String []s1=s.split(s);
  • (3).第三次大作业：

在第三次大作业中我学到了很多奇奇怪怪的特别牛的算法代码如下：

 Set<Integer> set=new HashSet<Integer>();
        for(i=0;i<n;i++)
            set.add(Integer.parseInt(s[i]));
           if(set.size()==n) 
       System.out.println("NO");
        else
          System.out.println("YES");

这是HashSet的用法，这叫做哈希集合，他有一个特别强大的功能就是可以实现自动去重，所以只需要判断一下所生成的哈希数集的个数与n相比即可。

class MyComparator implements Comparator<String>{
    @Override
    public int compare(String o0, String o1) {
        if(o0.length()>o1.length())
            return -1;
        else if(o0.length()==o1.length())
            return o0.compareToIgnoreCase(o1);
        else
            return 1;
    }
}

这是判断单词长度的函数，如果单词长度相等，那么比较它们的字符典

DecimalFormat  d=new DecimalFormat("0.000000");

根据自己的需求去自定义一个特殊的格式

 localdate=LocalDate.of(a[0],a[1],a[2]);
        localdate1=LocalDate.of(a1[0],a1[1],a1[2]);

LocalDate 数据类型的使用。

4.我的看法：

关于我自己的看法，我对于这三次大作业的看法是，通过这三次大作业，我们从中获得了许许多多的收获，比如对类的概念和语法的使用更加完善，同时，我们也在一次次的失败中吸取经验，获得成长，在一次次分数积累的过程中，便是我们成长的见证，所以我认为大作业是对我们非常有益的，所以希望我们以后要一定要更加认真的对待大作业中的每一道题，因为以后大作业一定会越来越难的，所以我们必须要更加努力的学习！
以上便是我对这次blog的前言做出的分析。

设计与分析：

我将会以三道菜单计价程序展开着重的分析，另外再对一些第三次作业中出现的新颖算法中出适当分析

  • 菜单(1)：

题目如下：

7-1 菜单计价程序-1
分数 30
作者 蔡轲
单位 南昌航空大学
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

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

输入格式:

每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。

输出格式:

订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

输入样例1：

在这里给出一组输入。例如：

麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:

在这里给出相应的输出。例如：

48
输入样例2:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例2:

在这里给出相应的输出。例如：

炒脆肚 does not exist
48

我的源码如下：

import java.util.Scanner;
    /*输入：name表示菜品名称;unit_price是菜品价格;
    计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）*/
        class Main{
        public static void main(String[] args){
            int j=0,k,sum=0,i,p=0;
            String s;
            String s1;
            Scanner scanner=new Scanner(System.in);
            Order order=new Order();
            while(true){
                s=scanner.nextLine();
                if(s.equals("end"))
                    break;
                for(k=0; ;k++) {
                    if (s.charAt(k) == ' ') {
                        s1 = s.substring(0, k);
                        break;
                    }
                }
                p=s.charAt(k+1)-'0';
                order.records[j]=order.addARecord(s1,p);
                if(!(order.records[j].d!=null))
                System.out.println(s1+" "+"does not exist");
                j++;
            }
            for(i=0;i<j;i++){
                if(order.records[i].d!=null)
                sum+=order.records[i].getPrice;
            }
            System.out.print(sum);

        }
    }

       class Dish {
        String name;
        int unit_price;

        public Dish(String name,int unit_price){
            this.name = name;
            this.unit_price = unit_price;
        }
        public Dish(){
        }
        public int getPrice(int portion){
            double unit_price1=unit_price;
            if(portion==2)
                unit_price1=unit_price*1.5;
            if(portion==3)
                unit_price1=unit_price*2;
            return (int)Math.round(unit_price1);
        }
    }
    /*输入：dishs菜品数组，用来保存所有菜品信息;
    searthDish(String dishName)根据菜名在菜谱中查找菜品信息，返回Dish对象;参数类型为String，名称为dishName;
     */
         class  Menu {
        Dish[] dishs=new Dish[4];
           public Menu() {

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



        Dish searthDish(String dishName){
              int i;
            int flag=0;
            for(i=0;i<4;i++){
                flag=0;
                if(dishs[i].name.equals(dishName)){
                    flag=1;break;
                }
            }
            if(!(flag != 1))
            return dishs[i];
            else
                return null;
        }
    }
    /*输入：d Dish类型的菜品;portion份额（1/2/3代表小/中/大份）getPrice()函数计价，计算本条记录的价格*/
    class Record {

        Dish d;
        int portion;
        int getPrice;
    }


    class Order {
        Record[] records=new Record[20];
        //int getTotalPrice()//计算订单的总价
        Record addARecord(String dishName,int portion){       //写一条加一条
          Menu menu=new Menu();
          Record record=new Record();
         record.d= menu.searthDish(dishName);
         record.portion=portion;
         if((record.d!=null))
         record.getPrice=record.d.getPrice(portion);
          return record;
        }
    }

类图如下：

关系报表图如下：

对类图报表及代码的分析与解释：

类图分析：
可以从类图看出，此题我使用了五个类，分别是record类，Dish类，Main类，Menu类和Older类。
报表分析
Lines： 指的是代码总行数
Statements：语句的行数，语句是以分号结尾的。这个C中有所不同。
Percent Branch Statement：分支数占总语句数的百分比
Method Call Statement：方法调用语句数
Percent Lines with Comments：注释语句占总语句数的百分比
Classes and Interfaces：类和接口数
Methods per Class：每个类平均包含函数个数
Average Statements per Method：每个函数平均包含的语句个数
函数复杂度（Function Complexity）复杂
所以从图中不难看出，在这几个方面中，达到绿色的是比较良好的代码，而红色超出绿色范围的则是不太良好的代码，我的这个大部分在范围内，只有class类可能不太妥当，另外圈复杂度也控制在了平均3.14的一个数据，总体还行.

  • 菜单(2)：

题目如下：

7-2 菜单计价程序-2
分数 40
作者 蔡轲
单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。

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

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

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

订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
点菜记录包含：序号、菜名、份额、份数。
份额可选项包括：1、2、3，分别代表小、中、大份。

删除记录格式：序号 delete

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

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

输入格式:

菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete

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

输出格式:

按顺序输出每条订单记录的处理信息，

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

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

最后输出订单上所有菜品的总价（整数数值），

本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的下一次作业中会做要求。

输入样例1:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例1:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
63
输入样例2:

订单中包含删除记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例2:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
27
输入样例3:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
end
输出样例3:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
63
输入样例4:

订单中包含删除信息以及不存在的菜品记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 delete
7 delete
end
输出样例4:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
27
输入样例5:

订单中包含删除信息以及不存在的菜品记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
end
输出样例5:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
63

我的源码如下：

import java.util.Scanner;

    /*输入：name表示菜品名称;unit_price是菜品价格;
    计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）*/
        class Main{
        public static void main(String[] args){
            int j=0,k,sum=0,i;
            String s;
            String s1;
            Scanner scanner=new Scanner(System.in);
            Order order=new Order();
            Menu menu=new Menu();
            while(true){
                s=scanner.next();//zuopanduan
                if(s.equals("end"))
                    break;
                if(s.charAt(0)-'0'<=100){
                    int orderNum=0,num=0,portion=0;
                    orderNum=s.charAt(0)-'0';
                    s1=scanner.next();
                    if(!(s1.charAt(0)!='d')) { //后续可能会有bug
                        if (order.findRecordByNum(order,orderNum, j) != 1)
                            System.out.println("delete error;");
                        else
                            order.delARecordByOrderNum(order,orderNum);
                    }
                    else {
                       int portion1=scanner.nextInt();
                       int num1=scanner.nextInt();
                       order.records[j]=order.addaRecord(menu,orderNum,s1,portion1,num1);
                        if(!(order.records[j].d!=null))
                            System.out.println(s1+" "+"does not exist");
                        else
                            System.out.println(order.records[j].orderNum+" "+order.records[j].d.name+" "+order.records[j].getPrice);
                        j++;
                    }

                }
                else {
                    int p=scanner.nextInt();
                    menu.addDish(s,p);
                }
            }
            for(i=0;i<j;i++)
                sum+=order.records[i].getPrice;
            System.out.print(sum);
        }
    }

       class Dish {
        String name;
        int unit_price;

        public Dish(String name,int unit_price){
            this.name = name;
            this.unit_price = unit_price;
        }
        public Dish(){
        }
        public int getPrice(int portion){
            double unit_price1=unit_price;
            if(portion==2)
                unit_price1=1.5*unit_price;
            if(portion==3)
                unit_price1=2*unit_price;
            return (int) Math.round(unit_price1);
        }
    }
    /*输入：dishs菜品数组，用来保存所有菜品信息;
    searthDish(String dishName)根据菜名在菜谱中查找菜品信息，返回Dish对象;参数类型为String，名称为dishName;
     */
     class  Menu {
       public Dish[] dishs=new Dish[20];
         int f=0;
         Dish searthDish(String dishName){
              int i;
            int flag=0;
            for(i=f-1;i>=0;i--){
                flag=0;
                if(dishs[i].name.equals(dishName)){
                    flag=1;break;
                }
            }
            if(!(flag != 1))
            return dishs[i];
            else
                return null;
        }
        public void addDish(String dishName,int unit_price){
               dishs[f]=new Dish(dishName,unit_price);
               f++;
        }
    }
    /*输入：d Dish类型的菜品;portion份额（1/2/3代表小/中/大份）getPrice()函数计价，计算本条记录的价格*/
    class Record {
        int orderNum;//序号\
        Dish d;//菜品\
        int portion;//份额（1/2/3代表小/中/大份）\
        int getPrice;
        int num;
    }


    class Order {
        Record[] records=new Record[20];
        //int getTotalPrice()//计算订单的总价
        /*Record addARecord(String dishName,int portion){       //写一条加一条
          Menu menu=new Menu();
          Record record=new Record();
         record.d= menu.searthDish(dishName);
         record.portion=portion;
         if((record.d!=null))
         record.getPrice=record.d.getPrice(portion);
          return record;
        }*/
        public Record addaRecord(Menu menu,int orderNum,String dishName,int portion,int num){
            Record record=new Record();
            record.orderNum=orderNum;
            record.num=num;
            record.d= menu.searthDish(dishName);
            record.portion=portion;
            if((record.d!=null))
                record.getPrice=record.d.getPrice(portion)*num;
            return record;
        }
      public void delARecordByOrderNum(Order order,int orderNum){
                     order.records[orderNum-1].getPrice=0;
                     return ;
        }
      public int findRecordByNum(Order order,int orderNum,int j){
               for(int i=0;i<j;i++)
                   if(!(order.records[i].orderNum!=orderNum))
                    return 1;
                
                    return 0;
       }
    }

类图如下：

关系报表图如下：

对类图报表及代码的分析与解释：

类图分析：
可以从类图看出，此题我仍然使用了五个类，分别是record类，Dish类，Main类，Menu类和Older类，因为是对第一题的拓展，与第一题不同的是，在系列二里，增加了输出方面的要求，其他在价格的计算上与第一题无差别。
报表分析
还是那几个数据
Lines： 指的是代码总行数
Statements：语句的行数，语句是以分号结尾的。这个C中有所不同。
Percent Branch Statement：分支数占总语句数的百分比
Method Call Statement：方法调用语句数
Percent Lines with Comments：注释语句占总语句数的百分比
Classes and Interfaces：类和接口数
Methods per Class：每个类平均包含函数个数
Average Statements per Method：每个函数平均包含的语句个数
函数复杂度（Function Complexity）复杂
还是老样子，在这几个方面中，达到绿色的是比较良好的代码，而红色超出绿色范围的则是不太良好的代码，我的这个大部分在范围内，相比于上次来讲，这次的平均圈复杂度是3.11，最大圈复杂度是5，超出了绿色的范围，这说明我可能使用了比较累赘的语法或重复语法，希望下次可以有所改进。

  • 菜单(3)：

题目如下：

7-1 菜单计价程序-3
分数 30
作者 蔡轲
单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。

删除记录格式：序号 delete

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

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

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

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

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

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

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

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

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

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

输入格式:

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

菜品记录格式：

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

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

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

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

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

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

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+”:”
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+“:”
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。

输入样例1:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 12/2/3
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end
输出样例1:

在这里给出相应的输出。例如：
``java
table 1:
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 38

#####输入样例2:
---
在这里给出一组输入。例如：
```java
麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 17/0/0
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例2:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 22
输入样例3:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 16/59/59
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end
输出样例3:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1 out of opening hours
输入样例4:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2022/12/5 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
7 delete
end
输出样例4:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
table 2: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
table 1 out of opening hours
table 2: 63
输入样例5:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2022/12/3 19/5/12
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 4 麻婆豆腐 1 1
7 delete
end
输出样例5:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
table 2: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
4 table 2 pay for table 1 12
delete error;
table 1: 63
table 2: 75

源码：

源码相比于第二次就输入发生了改变，所以只展示输入部分，剩余可参考第二次的代码

 while(true){
               String s=scanner.next();//zuopanduan
                if(s.equals("end"))
                    break;
                if(s.charAt(0)-'0'<=200){
                       if(s.charAt(0)=='t'){
                           i++;
                           resturant.tables[i]=new Table();///明天看
                           int tablenum=scanner.nextInt();
                           resturant.tables[i].tablenum=tablenum;
                           String time=scanner.nextLine();
                           String []times=time.split(" |\\/");
                        resturant.tables[i].localDateTime=LocalDateTime.of(Integer.parseInt(times[1]),Integer.parseInt(times[2]),Integer.parseInt(times[3]),Integer.parseInt(times[4]),Integer.parseInt(times[5]),Integer.parseInt(times[6]));
                    } else {
                           int ordernum0=s.charAt(0)-'0';
                        String s1=scanner.next();
                           if(s1.charAt(0)-'0'<=200) {
                               if (!(s1.charAt(0) != 'd')) { //后续可能会有bug
                                   if ((resturant.tables[i].findRecordByNum(resturant.tables[i],ordernum0,resturant.tables[i].i) != 1)&&(resturant.tables[i].findRecorddByNum(resturant.tables[i],ordernum0,resturant.tables[i].j) != 1))
                                       System.out.println("delete error;");
                               }
                               else {
                                   int tablenum=s.charAt(0)-'0';
                                   int ordernum=s1.charAt(0)-'0';
                                   String s2=scanner.next();
                                   int portion= scanner.nextInt();
                                   int num= scanner.nextInt();
                                   if(i!=0){
                                   resturant.tables[i].recordsd[resturant.tables[i].j]=resturant.tables[i].addaRecordd(menu,tablenum,ordernum,s2,portion,num);
                                   if(resturant.tables[i].recordsd[resturant.tables[i].j].d==null)
                                       System.out.println(s2 + " " + "does not exist");
                                   else
                                   System.out.println(resturant.tables[i].recordsd[resturant.tables[i].j].orderNum+" table "+resturant.tables[i].tablenum+" pay for table "+tablenum+" "+resturant.tables[i].recordsd[resturant.tables[i].j].getPrice);
                                   resturant.tables[i].j++;}
                               }
                           }
                      else{
                               int portion1 = scanner.nextInt();
                               int num1 = scanner.nextInt();
                               //resturant.tables[i]=new Table();////明天看
                               resturant.tables[i].records[resturant.tables[i].i] = resturant.tables[i].addaRecord(menu,ordernum0,s1,portion1, num1);
                               if ((resturant.tables[i].records[resturant.tables[i].i].d == null))
                                   System.out.println(s1 + " " + "does not exist");
                               else {
                                   if(resturant.tables[i].i==0) {
                                       System.out.println("table "+resturant.tables[i].tablenum+": ");
                                       System.out.println(s + " " + s1 + " " + resturant.tables[i].records[resturant.tables[i].i].getPrice);
                                   }
                                   else
                                       System.out.println(s + " " + s1 + " " + resturant.tables[i].records[resturant.tables[i].i].getPrice);
                               }
                               resturant.tables[i].i++;
                           }
                       }
                }
                else {
                    int p=scanner.nextInt();
                    menu.addDish(s,p);
                }
            }

类图如下：

关系报表图如下：

对类图报表及代码的分析与解释：

类图分析：
可以从类图看出，第三次我使用了六个类，分别是record类，Dish类，Main类，Menu类和Older类和Table类，相比于上题多增加了一个Table类，用于实现桌的功能。
报表分析
Lines： 指的是代码总行数
Statements：语句的行数，语句是以分号结尾的。这个C中有所不同。
Percent Branch Statement：分支数占总语句数的百分比
Method Call Statement：方法调用语句数
Percent Lines with Comments：注释语句占总语句数的百分比
Classes and Interfaces：类和接口数
Methods per Class：每个类平均包含函数个数
Average Statements per Method：每个函数平均包含的语句个数
函数复杂度（Function Complexity）复杂
从图中看，在这几个方面中，达到绿色的是比较良好的代码，而红色超出绿色范围的则是不太良好的代码，我的这个大部分在范围内，这次的Comment好像是注释的有点多，圈复杂度平均是2.67的一个，最大仍然是5.

踩坑心得：

其实对于这三道系列题，刚开始做的时候我踩得坑还不少，以下便是我在做这三道题的时候所踩得坑，希望以后可以不再犯，也希望对大家有所帮助。

  • 1：

像一些在以前c语言中所出现的低级错误，在java中还是不可避免的，比如未定义的字符，如图：

所以说像以上这几种情况，大家更应该多多注意，以后尽量杜绝这些情况
想用实例变量却在main函数外定义了变量：

关于这个情况就需要大家对实例变量和静态变量以及静态方法有一个较为清晰的认知。

  • 2:

除去比较低级的错误以后，我认为有一个错误是大家在学习java时都会遇到的，就是null，无论何时何地，想必大家都被null所深深的折磨吧，接下来我就说说自己对null情况的分析。 如图所示：

我们可能会经常遇到这种情况，其实这种多是我们没有new一个对象出来，我们只需要new一个就行了，如图所示


如图，代码便可以正常运行了
以上就是我的踩坑心得。

主要困难及改进建议

通过这三次的大作业来看，我认为菜单系列题还是有难度的，这三次作业的话，每一次都特别的做的特别的时间之长，才勉强拿到分数
，差不多基本到了后面一道题基本要花一天甚至两天的时间才有可能写完，并且还可能得不到全部的分数，另外就是我觉得在一些算法之类的题，也有一些难度，这也可能是做题少的原因吧！然后就改进建议的话，我觉得就某一道题，如果做不出来的话，一直卡测试点的话，其实也不是自己可能不会做吧，就是找不到测试点的时候，可能会很难，所以就是希望可以改进的时候，把测试点的条例说清楚一点，因为有时候卡一两个测试点，浪费一两天的时间，确实感觉到不值得，但是不去改进的话，又觉得放不下，其他要改进的方面，觉得都做的挺好的吧，没有什么要改变的了。

总结

历经了两三天之久，终于终于终于来到了最后的总结环节，可把我累坏了，接下来就让我对此次博客进行一个总结，首先，这次博客是进行在三次大作业后的，也就是说，每进行三次大作业，就要进行一次博客的总结，如果让我比较这个博客和大作业的话，我觉得这个博客总结会比较更加的累，因为他需要打的字非常非常的多，需要了解一些新的东西，也非常非常非常的多，但是意义上来讲，这个博客要比大作业的意义更加的好，因为它不仅使我们帮我们回忆起了前三次大作业中一些关键的知识点和一些关键的思路，同时也帮助我们更加了解了一些他们的基本关系，比如说在之前做大作业的时候，是根本不会想到用类图来理解他们的关系，同时也不会想到用报告分析来分析嗯自己代码的质量，比如说其中老师提到了一个叫做圈复杂度的概念，那么它就是来衡量你代码是否复杂的一个关键因素，可以看出我此次三次作业的平均复杂度都基本上是三左右，我看那个csd n上说一般优秀的代码是2到4左右，但是这菜单我们写的程序还是比较小的，所以可想而知，如果当我们的代码总量增加到了几百行，500行，甚至是上千行的时候，我们的圈复杂度就肉眼可见的在增长，所以我们现在就要打好基础，把代码的顺序理清，尽量的省略一些不必要的操作，简化代码程度，那么嗯，可以帮助我们在程序员这条道路上走的更远，希望大家有问题就要多去探索自己的问题，只有这样，我们每个人才会变得更加的优秀，所以我们仍然在路上，我们每个人都需要更加的努力，努力吧！以上的全部内容就是我对此次博客的全部分析，因为这毕竟是我第一次写博客，如果有写的不周到的地方，敬请谅解，以后我会学的更加多的知识来写出更好的作品，谢谢阅读。

posted @ 2023-04-01 22:53  hattyyyy  阅读(231)  评论(0)    收藏  举报