首页 > 其他分享 >PTA 1—3次题目集总结 Blog1

PTA 1—3次题目集总结 Blog1

时间：2023-05-24 14:35:40浏览次数：36  
标签：油淋 题目 记录 Blog1 PTA int 菜品 Dish 麻婆豆腐

一.前言

前三次题目集总的来说知识点很多，题量也很大，除了第一次题目简单，第二三次题目的难度跨度太大了，第一次都是很基础的题目，第二三次题目难度突然提高很多，措不及防，完成得很困难，由于菜单计价系统是第一次写，难度很大，完成的不太好。

二.设计与分析

第一次题目集：

总的来说，第一次题目集难度不大，其中大部分内容与上学期学的c语言很类似，容易上手，没有什么地方需要分析与解释的。

第二次题目集

7-1 菜单计价程序-1

某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

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

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

输入格式:

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

输出格式:

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

输入样例:

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

麻婆豆腐 2

西红柿炒蛋 3

end

输出样例:

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

48

输入样例1:

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

麻婆豆腐 2

炒脆肚 2

西红柿炒蛋 3

end

输出样例1:

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

炒脆肚 does not exist

48

 

 

附上源码

import java.util.Scanner;

 

public class Die {

 

    public static void main(String[] args){

       Scanner in = new Scanner(System.in);

       int y;

       int j=0;

      

       String x = in.next();

       Order z = new Order();

       Menu n = new Menu();

      

       while(!x.equals("end"))

       {

       y=in.nextInt();

       z.records[j] = new Record();

       z.records[j] = z.addARecord(x,y);

       j++;

       x=in.next();

           }

      

       for(int i=0;i<j;i++)

       {

       z.records[i].d=n.searthDish(z.records[i].d.name);

       }

       System.out.println(z.getTotalPrice());

           }

       }

 

       class Dish{

       String name;

       int unit_price;

       int getPrice(int portion){

       switch(portion)

       {

       case 1:return unit_price;

       case 2:if(unit_price==15||unit_price==9)return ((int)(unit_price*1.5))+1;

       else return unit_price*3/2;

       case 3:return unit_price*2;

       }

       return 0;

           }

       }

 

       class Record {

        int portion;

       Dish d=new Dish();

 

       int getPrice()

       {

       return d.getPrice(portion);

           }

       }

       class Order {

       Record[] records=new Record[20];

       int sum = 0;

       int count = 0;

       int getTotalPrice(){

       for(int i=0;i<count;i++){

       if(records[i].d!=null)

       sum+=records[i].getPrice();

           }

       return sum;

       }

       Record addARecord(String dishName,int portion){

       Record x=new Record();

       x.d.name=dishName;

       x.portion=portion;

       count++;

       return x;

           }

       }

      

      

       class Menu {

       Dish[] dishs = new Dish[10];

       Dish searthDish(String dishName){

       dishs[0] = new Dish();

       dishs[0].name = "西红柿炒蛋";dishs[0].unit_price = 15;

      

       dishs[1] = new Dish();

       dishs[1].name = "清炒土豆丝";dishs[1].unit_price = 12;

      

       dishs[2] = new Dish();

       dishs[2].name = "麻婆豆腐";dishs[2].unit_price = 12;

      

       dishs[3] = new Dish();

      dishs[3].name = "油淋生菜";dishs[3].unit_price = 9;

      

       boolean x = false;

       int i=0;

       for(i=0;i<4;i++){

       if(dishName.equals(dishs[i].name)==true){

       x=true;

       break;

           }

       }

       if(x==true)

       return dishs[i];

       else

       {

       System.out.println(dishName+" does not exist");

       return null;

              }

           }

       }

菜单系列的第一道题就给了我当头一棒，打得我措不及防，这道题目涉及到了类与类之间的相互调用，这道题目我共用创建了五个类，分别是Menu菜单，Record记录，Dish菜品，Order点菜，相互调用，完成了这道题。

 

7-2 菜单计价程序-2

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

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

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

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


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

删除记录格式：序号 delete

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

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

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。

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

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

Menu {
   Dish[] dishs ;//菜品数组，保存所有菜品信息
   Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
   Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}

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

Record {
   int orderNum;//序号\
   Dish d;//菜品\
   int portion;//份额（1/2/3代表小/中/大份）\
   int getPrice()//计价，计算本条记录的价格\
}

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

Order {
   Record[] records；//保存订单上每一道的记录
   int getTotalPrice()//计算订单的总价
   Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
   delARecordByOrderNum(int orderNum)//根据序号删除一条记录
   findRecordByNum(int orderNum)//根据序号查找一条记录
}

输入格式:

菜品记录格式：

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

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

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

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


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

输出格式:

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

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

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

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

本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。

输入样例:

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

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end

输出样例:

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

1 麻婆豆腐 36
2 油淋生菜 27
63

输入样例1:

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

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end

输出样例1:

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

1 麻婆豆腐 36
2 油淋生菜 27
27

输入样例2:

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

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
end

输出样例2:

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

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

输入样例3:

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

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 delete
7 delete
end

输出样例3:

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

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

输入样例4:

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

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

输出样例4:

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

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

 

源码附上：

import java.util.Scanner;

 

public class Die {

 

    public static void main(String[] args){

       Scanner q = new Scanner(System.in);

       Order my = new Order();

       Menu x = new Menu();

       String y="";

       String[] z = new String[10];

       y = q.nextLine();

      

       int i = 0;

       int k = 0;

       int a = 0;

       int a1= 0;

       int a2 = 0;

       int a3 = 0;

      

       while(!y.equals("end"))

       {

       z = y.split(" ");

       if(z.length==2&&!z[1].equals("delete"))

       {

       a = Integer.parseInt(z[1]);

       x.dishs[i]=new Dish();

       x.dishs[i] = x.addDish(z[0],a);

       i++;

       }

       if(z.length==4)

       {

       a1 = Integer.parseInt(z[0]);

       a2 = Integer.parseInt(z[2]);

       a3 = Integer.parseInt(z[3]);

      

       my.records[k] = new Record();

       my.records[k] = my.addARecord(a1,z[1],a2,a3);

       my.records[k].d=x.searthDish(z[1]);

      

       if(my.records[k].d==null)

       System.out.println(z[1]+" does not exist");

       else

       System.out.println(my.records[k].orderNum+" "+my.records[k].d.name+" "+my.records[k].getPrice());

       k++;

       }

      

       if(z[1].equals("delete"))

       {

       a1 = Integer.parseInt(z[0]);

       my.delARecordByOrderNum(a1);

           }

       y = q.nextLine();

       }

       System.out.println(my.getTotalPrice());

           }

       }

 

 

 

       class Order

       {

       Record[] records = new Record[10];

       int count = 0;

       int sum = 0;

       int i = 0;

       int getTotalPrice()

       {

       for(i=0;i<count;i++){

       if(records[i].d!=null)

       sum+=records[i].getPrice();

           }

       return sum;

           }

       Record addARecord(int orderNum,String dishName,int portion,int num)

       {

       Record z=new Record();

       z.orderNum = orderNum;

       z.d.name=dishName;

       z.portion=portion;

       z.num = num;

       count++;

       return z;

           }

       void delARecordByOrderNum(int orderNum){

       if(orderNum<=count)

       {

       records[orderNum-1].num=0;

           }

       else

       System.out.println("delete error;");

           }

       }

 

      

      

      

       class Menu

       {

       Dish[] dishs = new Dish[10];

       int t = 0;

       Dish searthDish(String dishName)

       {

       int flag = 0;

       int i;

       for(i=t-1;i>=0;i--){

       if(dishName.equals(dishs[i].name)==true)

       {

       flag = 1;

       break;

           }

       }

       if(flag==1)

       return dishs[i];

       else

       {

       return null;

           }

       }

       Dish addDish(String dishName,int unit_price)

       {

       Dish dish1 =new Dish();

       dish1.name = dishName;

       dish1.unit_price = unit_price;

       t++;

 

       return dish1;

           }

       }

 

      

       class Record

       {

       int orderNum;

       Dish d=new Dish();

       int portion;

       int num;

       int getPrice()

       {

       return num*d.getPrice(portion);

           }

       }

       class Dish

       {

       String name;

       int unit_price;

       int getPrice(int portion){

       switch(portion)

       {

       case 1:return unit_price;

       case 2:if(unit_price==15||unit_price==9)return ((int)(unit_price*1.5))+1;

       else return unit_price*3/2;

       case 3:return unit_price*2;

           }

       return 0;

           }

       }

菜单计价程序二比一要难上不少，增加了删除菜品的功能，其实结构和一差不多，就是更为复杂，更费脑子，当时感觉自己都快秃头了QwQ

 

7-1 菜单计价程序-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+英文空格+桌号+“:”+英文空格+当前桌的总价

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

输入格式:

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

菜品记录格式：

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

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

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

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

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

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

输出格式:

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

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

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

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

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

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

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

输入样例:

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

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 12/2/3
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end

输出样例:

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

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 38

输入样例1:

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

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 17/0/0
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end

输出样例1:

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

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 22

输入样例2:

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

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

输出样例2:

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

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1 out of opening hours

输入样例3:

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

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

输出样例3:

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

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

输入样例4:

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

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

输出样例4:

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

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

 

源码附上：

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.List;

import java.util.Scanner;

 

public class Die {

 

       static Scanner scanner = new Scanner(System.in);

 

       public static void main(String[] args) {

           Menu menu = new Menu();

           Order[] orders = new Order[100];

           int orderIdx = 0;

           while (scanner.hasNext()) {

               String line = scanner.nextLine();

               if (line.equals("end")) {

                   break;

               }

               String[] parts = line.split(" ");

               if (parts[0].equals("table")) {

                   String[] time = parts[3].split("/");

                   int year = Integer.parseInt(time[0]);

                   int month = Integer.parseInt(time[1]);

                   int day = Integer.parseInt(time[2]);

                   time = parts[4].split(":");

                   int hour = Integer.parseInt(time[0]);

                  int minute = Integer.parseInt(time[1]);

                  int second = Integer.parseInt(time[2]);

                   orders[orderIdx] = new Order(Integer.parseInt(parts[1]), year, month, day, hour, minute, second);

                   orderIdx++;

               } else if (parts[1].equals("delete")) {

                   int orderNum = Integer.parseInt(parts[0]);

                   Record record = orders[orderIdx - 1].findRecordByNum(orderNum);

                   if (record == null) {

                       System.out.println("delete error");

                   } else {

                       orders[orderIdx - 1].delARecordByOrderNum(orderNum);

                   }

               } else {

                   String dishName = parts[1];

                   Dish dish = menu.searthDish(dishName);

                   if (dish == null) {

                       dish = menu.addDish(dishName, Integer.parseInt(parts[2]));

                   }

                   int orderNum = Integer.parseInt(parts[0]);

                   int portion = Integer.parseInt(parts[2]);

                   int num = Integer.parseInt(parts[3]);

                   orders[orderIdx -1].addARecord(orderNum, dish, portion, num);

       }

       }

       for (int i = 0; i < orderIdx; i++) {

       System.out.println(orders[i].toString());

       }

       }

 

       public static class Menu {

       private List<Dish> dishes;

 

       public Menu() {

           dishes = new ArrayList<>();

       }

 

       public Dish searthDish(String name) {

           for (Dish dish : dishes) {

               if (dish.getName().equals(name)) {

                   return dish;

               }

           }

           return null;

       }

 

       public Dish addDish(String name, int price) {

           Dish dish = new Dish(name, price);

           dishes.add(dish);

           return dish;

       }

       }

 

       public static class Dish {

       private String name;

       private int price;

 

       public Dish(String name, int price) {

           this.name = name;

           this.price = price;

       }

 

       public String getName() {

           return name;

       }

 

       public int getPrice() {

           return price;

       }

       }

 

       public static class Order {

       private int tableNum;

       private List<Record> records;

       private Date date;

 

       public Order(int tableNum, int year, int month, int day, int hour, int minute, int second) {

           this.tableNum = tableNum;

           records = new ArrayList<>();

           Calendar calendar = Calendar.getInstance();

          calendar.set(year, month - 1, day, hour, minute, second);

       }

 

       public void addARecord(int orderNum, Dish dish, int portion, int num) {

           Record record = new Record(orderNum, dish, portion, num);

           records.add(record);

       }

 

       public Record findRecordByNum(int orderNum) {

           for (Record record : records) {

               if (((Object) record).getOrderNum() == orderNum) {

                   return record;

               }

           }

           return null;

       }

 

       public void delARecordByOrderNum(int orderNum) {

           Record record = findRecordByNum(orderNum);

           if (record != null) {

               records.remove(record);

           }

       }

 

       public int getTableNum() {

           return tableNum;

       }

 

       public Date getDate() {

           return date;

       }

           }

       }

菜单3比2难度翻倍，让我对Java类的编写和使用有了更深刻的理解。通过这个项目，我学会了如何在Java中创建类、使用列表和日期对象，并实现基本的输入和输出功能。

在编写代码的过程中，我遇到了一些挑战，例如如何正确地解析用户输入、如何在多个类之间传递数据等。通过仔细思考和查阅文档，我逐渐解决了这些问题，并成功地实现了一个简单的点餐系统。

 

三.踩坑心得

通过这三次pta题目集，我学到了很多：

1.  注意输入格式：在读取用户输入时，需要注意用户输入的格式，特别是日期和时间的格式。在这段代码中，日期和时间的格式是固定的，需要按照指定的格式进行输入，否则会导致程序出错。

2.  熟悉面向对象编程的基本概念：这段代码中涉及到了面向对象编程的一些基本概念，如类、对象、构造函数、方法等。熟悉这些概念对于理解代码的功能和实现非常有帮助。

3.  熟悉集合类的使用：这段代码中使用了List集合来存储菜单和点餐信息，熟悉集合类的使用可以帮助我们更加方便地管理和操作数据。

4.  小心空指针异常：在使用对象时，需要注意空指针异常的问题，尤其是在调用对象的方法时。在这段代码中，如果没有正确地初始化对象，就会导致空指针异常。

5.  学会调试程序：在编写代码时，难免会出现一些错误，学会调试程序可以帮助我们更快地找出问题所在并进行修改。

总之，这段代码是一个很好的面向对象编程的练习题，通过学习和实践，我们可以更好地掌握面向对象编程的相关知识和技能。

 

四.主要困难和改进建议

主要困难：

1.  变量命名不够规范：在这段代码中，有些变量的命名不够规范，不够清晰明了，比如parts、num等，这会给代码的阅读和维护带来一定的困难。

2.  代码可读性不够好：在这段代码中，有些代码的可读性不够好，比如一些复杂的if语句和循环语句，这会让代码难以理解和维护。

改进建议：

1.  规范变量命名：建议使用有意义的变量名，能够清晰地表达变量的含义和作用，提高代码的可读性和可维护性。

2.  提高代码可读性：建议使用更加简洁明了的语句，避免使用过于复杂的语句，增加代码的可读性和可维护性。

 

五.内容总结

这三次pta题目集帮助我更好地掌握面对编程的相关知识和技能，为我的java之旅打下了良好的基础，培养了独立动手能力，让自己的思维更为敏捷，敢于向难题动手，哪怕耗费一下午，一晚上也不会觉得浪费，只会感觉收获颇丰。

在这也感谢老师的辛勤教导，辛苦老师们了！

标签：油淋,题目,记录,Blog1,PTA,int,菜品,Dish,麻婆豆腐
From： https://www.cnblogs.com/lyh971433/p/17428188.html

相关文章

  • PTA题目集1~3的总结性Blog
    一、前言：我通过学习面向对象程序设计这门课程，深入掌握了Java语言的知识。截至目前，三个PTA作业，这些作业主要涉及Java的结构、类的运用、以及一些方法的使用，其中类的应用是重点。这三次作业的难度逐渐加大，同时作业量也在逐步增加。最令我印象深刻的是点菜，每一次都让我心如焦土，无可......
  • pta_【CPP0038】单向链表模板类
    #include<iostream>usingnamespacestd;template<typenameT>classNode{public:Node(Tdata):data(data),next(nullptr){cout<<"NodeConstructorrun"<<endl;}Node(constNode<T>&other)......
  • blog1
    前言    菜单类题目之外的其他的小题目都还好，差不多都做出来了，在做这些题目的同时我也学会了很多java语言的知识，明白了合理用JAVA中包含的自带的函数是一种便捷高效的方法 显而易见，此三次的PTA作业所考察的知识点以及难度呈现不断变大的趋势。PTA1作业难度简单，虽然题目量......
  • 每日打卡,pta题目
    给定一个长度不超过 104 的、仅由英文字母构成的字符串。请将字符重新调整顺序，按 PATestPATest.... 这样的顺序输出，并忽略其它字符。当然，六种字符的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按PATest的顺序打印，直到所有字符都被输出。输入格式：输入在一......
  • 周一（PTA简单题）例
    #include<iostream>#include<iomanip>usingnamespacestd;intmain(){intN,i,sex,b=0,g=0;floatscore,aver1,aver2,aver3,b1=0.0,g1=0.0;cin>>N;for(i=0;i<N;i++){cin>>sex;cin>>score;if(sex==1){b+=1;b1+=s......
  • 菜单题目集1~3
    一、前言 Java这三次题目集中第一周的九题：题目难度较低，比较基础，适合过渡。第二周的四题：题目难度较第一周有较大升级，java的面向对象性开始体现，类间关系及类与类之间属性方法的调用难度加大，java的难处初显。第三周的七题：第三周的题目难易混杂，7-1菜单计价程序-3是第二周两个菜......
  • BLOG-1 (PTA 1~3)
    前言在本阶段的三次题目集中，我们主要涉及了菜单计价程序的设计与实现。这些题目涵盖了点菜订单的处理、菜品价格计算、代点菜功能以及总价的计算等方面的内容。通过完成这些题目，我们可以加深对Java编程语言的理解，熟悉面向对象的设计思想，并应用这些知识解决实际问题。设计与分析......
  • 题目集 1~3 的总结性 Blog
    前言:题目集1~3的知识点、题量、难度等情况如下:知识点：JAVA基础，基础算法，面向对象程序设计题量：共计3道题目难度：题目从易到难，分为三个层次，分别为入门、中等和高级设计与分析:本次Blog重点分析菜单计价系列题目，即题目集2的7-1、7-2以及题目集3的7-1。这三......
  • 每天打卡一小时 第三十一天 PTA520钻石 争霸赛
    第一题  源代码#include<iostream>usingnamespacestd;intmain(){intn;cin>>n;cout<<"520"<<n<<"Times!";}第一题，简简单单打印输出第二题 源代码#include<iostream>usingnamespacestd;intmain(......
  • 题目奶酪单
    Manacher模板:LuoguP3805反演:LuoguP3279总结......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99