一、前言
本学期开展了面向对象程序设计这门课程，开始了Java语言的学习。目前，我们已完成三次pta大作业，让我收获了很多，慢慢从上个学期C语言面向过程的编程思想转变为面向对象程序设计的思想。现对三次作业做概括分析：
1.第一次作业
二、设计与分析
1.第一次作业
共九道题目，难度一般，均为基础题目，主要涉及到的主要是对java语法的认识，以及顺序结构、循环结构、选择结构等知识，这些与C语言并无太大区别，所以完成起来较为顺畅，得分为100分，但有一些数据类型的差异导致结果错误的问题，通过尝试也解决了。后续分析我将分析7-8巴比伦法求平方根近似值。
2.第二次作业
共四道题目，难度相较第一次大大提升，主要涉及到对java工具包中所包含的一些方法的认识和使用，与C相比所能使用的方法更丰富（在写的时候并不知道），并且涉及到对类的编写，当时我对类的理解不够，使用类也不熟练，所以这次作业完成情况并不理想，在后续的学习中，我才逐渐明白，类可以说是C语言中结构体的升级版，其中不但包括成员属性，也包括成员方法。后续的分析我将分析7-1 菜单计价程序-1，7-2 菜单计价程序-2，7-3 jmu-java-日期类的基本使用。
3.第三次作业
共七道题目，难度相较第二次有所下降，主要涉及到类变量和类方法和面向对象编程之封装性，还有时间有关的类方法，以及字符串相关知识，属于Java的一些进阶知识，除了的一道菜单计价系列3，其余的题目，我通过自学相关内容都完成了。在后续的分析中，我将分析7-1 菜单计价程序-3，7-2 有重复的数据。
以及对数组的使用，java中的数组是一种对象，在声明时需要借助关键词new
7-8 巴比伦法求平方根近似值 分数 10 作者 蔡轲 单位 南昌航空大学巴比伦法求n的近似值可以用以下公式：
nextGuess = (lastGuess+n/lastGuess)/2
程序初始运行时lastGuess可赋予一个最初的猜测值。当由公式求得的nextGuess和lastGuess相差较大时，把nextGuess的值赋给lastGuess，继续以上过程，直至nextGuess和lastGuess几乎相同，此时lastGuess或者nextGuess就是平方根的近似值。
本题要求：nextGuess和lastGuess的差值小于0.00001时认为两者几乎相同
输入格式:
1、两个浮点数，以空格分隔，第一个是n，第二个是lastGuess最初的猜测值。例如：2 1。
2、若输入的两个数中包含负数或者lastGuess初始输入为0，认定为非法输入
输出格式:
1、输出n的平方根近似值：lastGuess。例如：1.4142157
2、非法输入时输出："Wrong Format"
输入样例:
在这里给出一组输入。例如：
2 1
输出样例:
在这里给出相应的输出。例如：
1.4142157
输入样例1:
在这里给出一组输入1。例如：
2 -1
输出样例:
在这里给出相应的输出。例如：
Wrong Format
import java.util.*;
public class Main
{
public static void main(String []args){
Scanner input = new Scanner(System.in);
float a=input.nextFloat();//n
float b=input.nextFloat();//lastGuess
if(a<0||b<=0){
System.out.println("Wrong Format");
return;
}
float c=(b+a/b)/2; //nextGuess
while(Math.abs(c-b)>=0.00001)
{
b=c;
c=(b+a/b)/2;
}
System.out.println((float)b);
}
}
这道题本身难度不大，主要问题在于不同数据类型计算带来的误差，根据我所搜索的知识可知：单精度与双精度精确范围不同，从运行结果来说，单精度浮点数小数部分只有前6位是准确的，而双精度浮点数小数部分9位都是准确的。最后，测试了很多遍，发现用float类型可以通过测试。
2.
7-1 菜单计价程序-1 分数 30 作者 蔡轲 单位 南昌航空大学某饭店提供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.*;
public class Main{
public static void main(String[] args) {
Scanner n = new Scanner(System.in);
String dish;
int portion;
double price=0;
double tprice=0;
while(true)
{
dish = n.next();
if (dish.equals("end"))
break;
portion = n.nextInt();
switch (dish)
{
case "西红柿炒蛋":
{
switch(portion)
{ case 1:
price=15;break;
case 2:
price =15*1.5;break;
case 3:
price=15*2;
break;}
}
break;
case "清炒土豆丝":
{
switch(portion)
{ case 1:
price=12;break;
case 2:
price =12*1.5;break;
case 3:
price=12*2;break;}
}
break;
case "麻婆豆腐":
{
switch(portion)
{ case 1:
price=12;break;
case 2:
price =12*1.5;break;
case 3:
price=12*2;break;}
}
break;
case "油淋生菜":
{
switch(portion)
{ case 1:
price=9;break;
case 2:
price =9*1.5;break;
case 3:
price=9*2;break;
}}
break;
default:
System.out.println(dish+' '+"does not exist");
continue;}
tprice+=price;
}
System.out.println(Math.round(tprice));
}
}
这是菜单计价系列的第一题，也是我该系列唯一满分的一题，分析整个菜单系列，我觉得我存在的问题没有转变对面向对象的编程思想，回顾这道题，我用的还是上个学期程序设计基础所学的面向过程的编程思想，并且我不会使用类及类方法；还有一个比较严重的问题，就是第一次写这个作业的受挫导致我产生了畏难心理，后续有些不太相碰这道题，其实这种想法是不对的，我现在也在慢慢克服这个问题，尝试写菜单计价系列的第二题。
除此之外，我在写这道题目的时候，也发现在如果结尾的输出函数”System.out.println(Math.round(tprice));“，不使用Math.round()的话，会造成部分结果错误。Math.round其实就是四舍五入，以下为我搜索到的相关资料：如果内容不是个数字，返回0;\n\n如果内容负无限大或者小于等于long的最小值，返回Long.MIN_VALUE;\n\n如果内容正无限大或者大于等于long的最大值，返回Long.MAX_VALUE;
3.
7-2 菜单计价程序-2
分数 40
全屏浏览题目
切换布局
作者 蔡轲
单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
String []menu =new String[500];
int []price=new int[500];
String menuName;
int inputPrice;
int i=0;
String wholeJudge;
while(true)
{
int reption=1;
menuName=input.next();
if(menuName.equals("1"))
{
wholeJudge="1";
break;
}
if(menuName.equals("end"))
{
wholeJudge="0";
break;
}
inputPrice=input.nextInt();
for(int k=0;k<i;k++)
if(menuName.equals(menu[k]))
{
price[k]=inputPrice;reption=0;
break;
}
if(reption==1)
{
menu[i]=menuName;
price[i]=inputPrice;
i++;
}
}
int everyPrice=0;
int totalPrice = 0;
int count=0;
int []recording=new int[100];
int re=0;
int judge3=1,judge2=0;
String endJudge="";
if(wholeJudge.equals("1"))
while(!wholeJudge.equals("end"))
{
everyPrice=0;
int flag=0;
String order=input.next();
if(order.equals("delete"))
{
if(judge2==1&&judge3==0)
wholeJudge = endJudge;
int p=Integer.parseInt(wholeJudge);
if(p<1||p>count||recording[p-1]==0)
System.out.println("delete error;");
if(p>=1&&p<=count&&recording[p-1]!=0)
{
totalPrice -= recording[p-1];
recording[p-1]=0;
}
endJudge = input.next();
judge3 = 0;
if(endJudge.equals("end"))
break;
else
{
judge2=1;
wholeJudge=endJudge;
continue;
}
}
else judge3=1;
int size1=input.nextInt();
int b=input.nextInt();
for(int j=0;j<i;j++)
{
if(order.equals(menu[j]))
{
flag=1;
if(size1==1)everyPrice+=price[j];
if(size1==2)
{
if(price[j]%2==1)
everyPrice+=price[j]*1.5+1;
else
everyPrice+=price[j]*1.5;
}
if(size1==3)
everyPrice+=2*price[j];
}
}
if(flag==0)
{
recording[re++]=0;
System.out.println(order+" does not exist");
count++;
}
if(flag==1)
{
everyPrice*=b;
totalPrice+=everyPrice;
recording[re++]=everyPrice;
System.out.println(wholeJudge+" "+order+" "+everyPrice);
count++;
}
wholeJudge=input.next();
}
if(!wholeJudge.equals("0"))
System.out.println(totalPrice);
else System.out.println("0");
}
}
以上为我仿写的代码，其实后来发现难度并没有想象的那么大，主要还是对类的创建及使用不够熟练
4.
7-3 jmu-java-日期类的基本使用
分数 15
全屏浏览题目
切换布局
作者 郑如滨
单位 集美大学
给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。
输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。
输入样例1:
第一行日期非法、第二行有日期非法
2020-02-30
2020-02-30 2020-01-02
输出样例1:
2020-02-30无效!
2020-02-30或2020-01-02中有不合法的日期.
输入样例2:
均有效且合法
2021-02-28
2019-08-01 2020-01-02
输出样例2:
2021-02-28是当年第59天,当月第28天,当周第7天.
2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1.
输入样例3:
日期均有效，但结束日期早于开始日期
2020-02-28
2020-02-02 2020-02-01
输出样例3:
2020-02-28是闰年.
2020-02-28是当年第59天,当月第28天,当周第5天.
2020-02-01早于2020-02-02,不合法!
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
这道题我开始也不会写来着，光是检验时间合法性和判断日期所在年月日就写了一百多行，就放弃了。但是在下一周学完Java日期时间类以后，发现这道题还是比较好写的，还是应该加强自学能力
4.
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"
参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。
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
代码长度限制
16 KB
时间限制
400 ms
内存限制
第三次作业的时间比较紧，题目量也不小，所以我当时放弃写这道题了，我主要把菜单计价系列2重新写了,但其实从我写的菜单计价2的圈复杂度和软件质量的表可以看出我这个题的复杂度是非常高的，效率低，维护成本高ifelse
语句使用过多，代码执行效率过低。如果要是想要改进的话，应该把if else语句去掉，换成数组或switch，便可以大大提升我们的编程效率。所以怎么去创建适合的类和类方法还是我现在比较薄弱的点
5.
7-2 有重复的数据
分数 10
全屏浏览题目
切换布局
作者 翁恺
单位 浙江大学
在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。
输入格式:
你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。
输出格式:
如果这些整数中存在重复的，就输出：
YES
否则，就输出：
NO
输入样例:
5
1 2 3 1 4
输出样例:
YES
代码长度限制
16 KB
时间限制
800 ms
内存限制
64 MB
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int i;
int n=input.nextInt();
input.nextLine();
String a = input.nextLine();
String[] b = a.split(" ");
Set<Integer> set = new HashSet<Integer>();
for(i=0; i<n; i++)
{
set.add(Integer.parseInt(b[i]));
}
if (set.size() == n) {
System.out.println("NO");
}else {
System.out.println("YES");
}
}
}
本题使用LinkedHashSet,主要是因为本题数据范围大，数据复杂度高，使用选择排序法和冒泡排序法都会无法通过测试点，LinkHashSet是Set实现类HashSet的一个子类，使用链表来维护元素的次序。本题需要保证原有的顺序实现去重，所以需使用LinkedHashSet。
三、踩坑心得
1.第一次作业中的精度问题，不同数据类型计算带来的误差，根据我所搜索的知识可知：单精度与双精度精确范围不同，所以开始我有好几道题死活通不过测试点，一直在显示结果错误（如上一部分所分析的7-8），今后在写代码的时候也应注意这个问题
2.第三次作业中的7-2 有重复的数据这道题我开始一直是想把数据存入数组，然后对比数组元素是否重复，但是这样是通过不了测试点的，时间复杂度太高。然后，后面学习才知道可以将数据存入Hashset集合，再通过set.size()ba判断集合中对象个数是否减少（Set集合是由一串无序的，不能重复得相同类型元素构成的集合）
3.第三次作业中的7-4 单词统计与排序要求从键盘录入一段英文文本（句子之间的标点符号只包括“,”或“.”，单词之间、单词与标点之间都以" "分割），我后来学习到中的Java的string类型提供了一个Split方法，可以用来分割字符串。该方法接受一个字符数组作为参数，表示分割字符串的分隔符，返回一个字符串数组，其中的每个元素都是原始字符串中被分隔符分割的部分。
4.第三次作业中的7-7 判断两个日期的先后，计算间隔天数、周数，通过这道题，我了解了通过查询Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法，所以Java相较于我们上个学期学习的C语言有很多类工具与方法，我们还是要在课余时间多多自学。
四.主要困难和改进建议
1.代码的复杂度高，编程的质量不高，我认为要减少选择语句if else，改用switch或者数组，这样可以提高程序运行效率。
2.对于类的理解不够，一个类里面的属性与方法，应该有单一原则，单一职责原则核心思想是一个类，最好就做一件事。就如老师上课所说的类与类之间的关联性越小越好，而我所写的一些程序，互相关联的太多，导致不太好改。测试对于编码质量是非常重要的，虽然我们pta不对这个做要求，我们也应该对自己所编写的代码持有高度的严谨性，尽可能提高代码质量。
五.总结
博客作业对我们来说是一种很重要的总结并反思的机会。以下是我对此次博客的内容进行总结：
从我自身的角度，三次作业我学习了解了类的构造方法、方法的调用，以及参数传递、对象的构造与使用；并且熟悉了循环结构、控制结构；掌握了数据的输入与输出；同时明白了程序编写结构清晰、逻辑正确、功能完善的java代码的重要性
从课堂的角度，线上线下相结合的模式。线上需通过学习通自学相关Java内容，老师根据题目的完成情况讲产生的学各种知识， 这种课堂模式非常具有创新性，大大增强了课堂效率。但其实从另外一方面也很考验我的自觉性，我经常会因为没有及时看网课而导致课跟不上，这也是我需要改的点。除此之外，由于题目难度较大（对我来说），也希望老师在课堂上面，除了基本知识的讲解，可以讲解一下作业。
标签：输出,总结性,题目,记录,int,Blog,菜品,麻婆豆腐,输入 From： https://www.cnblogs.com/as11/p/17270260.html