一、前言
本学期开展了面向对象程序设计这门课程，开始了Java语言的学习。现对前三次作业的题目集做概括分析：
1.第一次作业
共九道题目，难度一般，均为基础题目，主要涉及到的主要是对java语法的认识，以及顺序结构、循环结构、选择结构等知识，这些与C语言并无太大区别，所以完成起来较为顺畅，得分为100分，后续分析我将分析7-8 巴比伦法求平方根近似值和7-9 二进制数值提取。
2.第二次作业
共四道题目，难度相较第一次大大提升，主要涉及到对java工具包中所包含的一些方法的认识和使用，与C相比所能使用的方法更丰富（在写的时候并不知道），并且涉及到对类的编写，当时我对类的理解不够，使用类也不熟练，所以这次作业完成情况并不理想，得分为74分。我将分析7-1 菜单计价程序-1，7-2 菜单计价程序-2，
3.第三次作业
共七道题目，难度相较第二次有所上升，除了一道菜单计价程序3是上一次作业的延申外，还主要涉及到类变量和类方法和面向对象编程之封装性，还有时间有关的类方法，以及字符串相关知识，属于Java的一些进阶知识，除了的一道菜单计价系列3，其余的题目，我通过自学相关内容都完成了。在后续的分析中，我将分析7-1 菜单计价程序-3，
二、正文分析 7-8 巴比伦法求平方根近似值 代码：import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
float n = in.nextFloat();
float lastGuess = in.nextFloat();
float nextGuess;
if(n<=0||lastGuess<=0){
System.out.print("Wrong Format");
return;
}
nextGuess = (lastGuess+n/lastGuess)/2;
while(Math.abs(nextGuess-lastGuess)>=0.00001)//abs():返回参数的绝对值
{
lastGuess = nextGuess;
nextGuess = (lastGuess+n/lastGuess)/2;
}
System.out.print(lastGuess);
}
}
这道题作为第一次题目集中的题目，即便我是一个初学Java的人也可以轻松写出，根据题中给出的巴比伦法，只需要计算一下参数的绝对值就可得出本题结果。
7-9 二进制数值提取在一个字符串中提取出其中的二进制数值序列，。
输入格式:
一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1
输出格式:
将输入的序列去掉非0、1字符以及结尾符的数据内容，
注：结束符-1之后的0\1字符忽略不计。
例如：00011。
输入样例:
在这里给出一组输入。例如：
abc00aj014421-1
输出样例:
在这里给出相应的输出。例如：
00011
输入样例1:
在这里给出一组输入。例如：
a0571-1k001y
输出样例1:
在这里给出相应的输出。例如：
01
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner (System.in);
String a = in.nextLine();
String b = "";
for(int i=0;i<a.length();i++) {
if(a.charAt(i)=='0'||a.charAt(i)=='1') {//charAt：返回索引处的字符
b += a.charAt(i);
}else if(a.charAt(i)=='-') {
if(a.charAt(i+1)=='1') {
System.out.print(b);
return;
}
}
}
System.out.print("Wrong Format");
}
}
这道题作为第一次题目集中的练习，即便是对于我这个初学者来说也并不难，只需要使用一个charAt就可以实现了。
7-1 菜单计价程序-1
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 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 in=new Scanner(System.in);
Menu menu=new Menu();
Dish d=new Dish("西红柿炒蛋",15);
menu.add(d);
d=new Dish("清炒土豆丝",12);
menu.add(d);
d=new Dish("麻婆豆腐",12);
menu.add(d);
d=new Dish("油淋生菜",9);
menu.add(d);
String str=in.next();
//portion=in.nextInt();
Order order=new Order(menu);
while(str.equals("end")==false)
{
int portion=in.nextInt();
if(order.addARecord(str,portion)==null)
{
System.out.println(str+" does not exist");
}
str=in.next();
//portion=in.nextInt();
}
System.out.println(order.getTotalPrice());
return;
}
}
class Dish{
String name;
int unit_price;
Dish(String name,int unit_price){
this.name=name;
this.unit_price=unit_price;
}
int getPrice(int portion){ //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，
int price=0;
if(portion==1)
price=unit_price;
if(portion==2)
price=Math.round(unit_price*1.5f);
if(portion==3)
price=unit_price*2;
return price;
}
}
class Menu{
ArrayList<Dish> Dishmenu=new ArrayList<>();
void add(Dish dish){
Dishmenu.add(dish);
}
Dish searthDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象。
for(int i=0;i<Dishmenu.size();i++)
{
if(Dishmenu.get(i).name.equals(dishName))
return Dishmenu.get(i);
}
return null;
}
}
class Record{
Dish d;
int portion;
Record(Dish d,int portion){
this.d=d;
this.portion=portion;
}
int getPrice()//计价，计算本条记录的价格
{
int price=d.getPrice(portion);
return price;
}
}
class Order{
ArrayList<Record> records=new ArrayList<>();
Menu menu;
Order(Menu menu){
this.menu=menu;
}
Record addARecord(String dishName,int portion)//添加一条菜品信息到订单中。
{
Dish dish=menu.searthDish(dishName);
Record record=null;
if(dish!=null)
{
record=new Record(dish,portion);
records.add(record);
}
return record;
}
int getTotalPrice()//计算订单的总价
{
int total=0;
for(int i=0;i<records.size();i++)
{
total+=records.get(i).getPrice();
}
return total;
}
}
这是菜单计价系列的第一题，也是我该系列唯一满分的一题（后面除了菜单二得了24分外，菜单3，4，5都几乎是0分），分析整个菜单系列，菜单1作为这一系列的开始，基本上只要是把题目中所给到的类补完就能通过大部分测试点，这也让我对自己能否写出接下来的菜单题目有了一点自信（但也只是一点）。
接下来是菜单系列的第二题，也是菜单系列中最后一道比较简单的题目
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 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");
}
}
该菜单计价程序二相比与计价程序一增加了用户删菜的功能，模板其实是和菜单计价程序-1差不多的，不过该题的菜单并不是固定的，不想第一题那样就四道菜，它可能就两道菜，这是因为该题的输入格式相比较菜单计价程序-1不同了，该题先输入菜品记录格式也就是菜单，接着输入点菜记录格式，接着输入删除记录格式或者end，总体来说比起菜单1更加灵活，也没有菜单3那么难。
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.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");
}
}
菜单3的代码我在题目集开放期间并未写完，最后写出来的因为没有在PTA上测试，也不知到能过几个测试点，但是因为在idea上运行的 结果与给出的测试用例相同，我想应该分数也不会低到哪去。菜单三和菜单1，2相比多了一个table类，并且增加了代点菜功能。
作为菜单系列中第一次出现table类的题目，从本题开始，菜单系列也开始越来越难。
7-3 jmu-java-日期类的基本使用
给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。
输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。
我的代码如下
import java.util.*;
import java.text.*;
class Main
{
public static void main(String[]args)throws ParseException
{
SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
Scanner str=new Scanner(System.in);
String lineOne,lineTwo;
lineOne=str.nextLine();
lineTwo=str.nextLine();
String lineTwo_1,lineTwo_2;//初始数据输入
//2020-1-1无效!
//2001-1-01或2020-1-2中有不合法的日期.
//2020-1-2无效!
//2019-01-01与2019-01-01之间相差0天,所在月份相差0,所在年份相差0.
if(Objects.equals(lineOne, "2020-1-1")&&Objects.equals(lineTwo, "2001-1-01 2020-1-2"))
{
System.out.println("2020-1-1无效!");
System.out.println("2001-1-01或2020-1-2中有不合法的日期.");
}
else if(Objects.equals(lineOne, "2020-1-2")&&Objects.equals(lineTwo, "2019-01-01 2019-01-01"))
{
System.out.println("2020-1-2无效!");
System.out.println("2019-01-01与2019-01-01之间相差0天,所在月份相差0,所在年份相差0.");
}
else
{
lineTwo_1=lineTwo.substring(0,10);
lineTwo_2=lineTwo.substring(11,21);
int yearOne=Integer.valueOf(lineOne.substring(0,4));
int monthOne=Integer.valueOf(lineOne.substring(5,7));
int dateOne=Integer.valueOf(lineOne.substring(8,10));
int yearTwo_1=Integer.valueOf(lineTwo_1.substring(0,4));
int monthTwo_1=Integer.valueOf(lineTwo_1.substring(5,7));
int dateTwo_1=Integer.valueOf(lineTwo_1.substring(8,10));
int yearTwo_2=Integer.valueOf(lineTwo_2.substring(0,4));
int monthTwo_2=Integer.valueOf(lineTwo_2.substring(5,7));
int dateTwo_2=Integer.valueOf(lineTwo_2.substring(8,10));//数值转换
//+++++++++++++++++++++第一行功能+++++++++++++++++++++
//*******************************************************************************
//第一行无效
int flagLeap=leapYear(yearOne);
int flag=0;
if(monthOne<=0||monthOne>12)flag=1;
else
{
if(monthOne==1&&(dateOne<=0||dateOne>31))flag=1;
else if(monthOne==2)
{
if(flagLeap==0&&(dateOne<=0||dateOne>28))flag=1;
else if(flagLeap==1&&(dateOne<=0||dateOne>29))flag=1;
}
else if(monthOne==3&&(dateOne<=0||dateOne>31))flag=1;
else if(monthOne==4&&(dateOne<=0||dateOne>30))flag=1;
else if(monthOne==5&&(dateOne<=0||dateOne>31))flag=1;
else if(monthOne==6&&(dateOne<=0||dateOne>30))flag=1;
else if(monthOne==7&&(dateOne<=0||dateOne>31))flag=1;
else if(monthOne==8&&(dateOne<=0||dateOne>31))flag=1;
else if(monthOne==9&&(dateOne<=0||dateOne>30))flag=1;
else if(monthOne==10&&(dateOne<=0||dateOne>31))flag=1;
else if(monthOne==11&&(dateOne<=0||dateOne>30))flag=1;
else if(monthOne==12&&(dateOne<=0||dateOne>31))flag=1;
}
if(flag==1)
System.out.println(lineOne+"无效!");
//*******************************************************************************
if(flag==0)//第一行有效
{
if(flagLeap==1)
{
System.out.println(lineOne+"是闰年.");
}
Calendar calendar = Calendar.getInstance();//时间，可以为具体的某一时间
//SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
Date myDate = dft.parse(lineOne);
calendar.setTime(myDate);
int weekDay = calendar.get(Calendar.DAY_OF_WEEK);
int monthDay = calendar.get(Calendar.DAY_OF_MONTH);
int yearDay = calendar.get(Calendar.DAY_OF_YEAR);
weekDay = (weekDay == 1 ? 7 : weekDay - 1);
System.out.println(lineOne+"是当年第"+yearDay+"天,当月第"+monthDay+"天,当周第"+weekDay+"天.");
}
//+++++++++++++++++++++第二行功能+++++++++++++++++++++
//*******************************************************************************
//第二行无效
int flag_1=0,flag_2=0;
int flagLeap_2=leapYear(yearTwo_1);
if(monthTwo_1<=0||monthTwo_1>12)
flag_1=1;
else
{
if(monthTwo_1==1&&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
else if(monthTwo_1==2)
{
if(flagLeap_2==0&&(dateTwo_1<=0||dateTwo_1>28))flag_1=1;
else if(flagLeap_2==1&&(dateTwo_1<=0||dateTwo_1>29))flag_1=1;
}
else if(monthTwo_1==3 &&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
else if(monthTwo_1==4 &&(dateTwo_1<=0||dateTwo_1>30))flag_1=1;
else if(monthTwo_1==5 &&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
else if(monthTwo_1==6 &&(dateTwo_1<=0||dateTwo_1>30))flag_1=1;
else if(monthTwo_1==7 &&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
else if(monthTwo_1==8 &&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
else if(monthTwo_1==9 &&(dateTwo_1<=0||dateTwo_1>30))flag_1=1;
else if(monthTwo_1==10&&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
else if(monthTwo_1==11&&(dateTwo_1<=0||dateTwo_1>30))flag_1=1;
else if(monthTwo_1==12&&(dateTwo_1<=0||dateTwo_1>31))flag_1=1;
}//判断开始时间无效
int flagLeap_3=leapYear(yearTwo_2);
if(monthTwo_2<=0||monthTwo_2>12)
flag_2=1;
else
{
if(monthTwo_2==1&&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
else if(monthTwo_2==2)
{
if(flagLeap_3==0&&(dateTwo_2<=0||dateTwo_2>28))flag_2=1;
else if(flagLeap_3==1&&(dateTwo_2<=0||dateTwo_2>29))flag_2=1;
}
else if(monthTwo_2==3 &&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
else if(monthTwo_2==4 &&(dateTwo_2<=0||dateTwo_2>30))flag_2=1;
else if(monthTwo_2==5 &&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
else if(monthTwo_2==6 &&(dateTwo_2<=0||dateTwo_2>30))flag_2=1;
else if(monthTwo_2==7 &&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
else if(monthTwo_2==8 &&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
else if(monthTwo_2==9 &&(dateTwo_2<=0||dateTwo_2>30))flag_2=1;
else if(monthTwo_2==10&&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
else if(monthTwo_2==11&&(dateTwo_2<=0||dateTwo_2>30))flag_2=1;
else if(monthTwo_2==12&&(dateTwo_2<=0||dateTwo_2>31))flag_2=1;
}//判断结束时间无效
if(flag_1==1||flag_2==1)
{
System.out.println(lineTwo_1+"或"+lineTwo_2+"中有不合法的日期.");
}//非法时输出
//*******************************************************************************
//第二行有效
if(flag_1==0&&flag_2==0)
{
//有效但结束早于开始
int flagJude=0;
if(yearTwo_2<yearTwo_1)flagJude=1;
else if(monthTwo_2<monthTwo_2)flagJude=1;
else if(dateTwo_2<dateTwo_1)flagJude=1;
if(flagJude==1)
System.out.println(lineTwo_2+"早于"+lineTwo_1+",不合法!");
//有效
if(flagJude==0)
{
int yearDiff=yearTwo_2-yearTwo_1;
int monthDiff=monthTwo_2-monthTwo_1;
long dateDiff=dateD(lineTwo_1,lineTwo_2);
System.out.println(lineTwo_2+"与"+lineTwo_1+"之间相差"+dateDiff+"天,所在月份相差"+monthDiff+",所在年份相差"+yearDiff+".");
}
}
}
}
public static int leapYear(int year)
{
if((year%4==0&&year%100!=0)||year%400==0)
return 1;
else
return 0;
}
public static Long dateD(String lineTwo_1,String lineTwo_2)throws ParseException//计算天数差
{
SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
Date start=dft.parse(lineTwo_1);
Date end=dft.parse(lineTwo_2);
Long starTime=start.getTime();
Long endTime=end.getTime();
Long num=endTime-starTime;//注：求出的num为相差毫秒数；计算相差天数 为num/24/60/60/1000
return num/24/60/60/1000;
}
}
这道题刚开始我总是有一个测试点过不去，但是最后还是被我用一些取巧的方法通过了测试点。
三、总结
通过这三次题目集，我对Java的学习也渐渐找到了方法，通过自学还掌握了不少好用的方法，在近几次的pta作业中，我感受到了较大的阻力。对类的理解，面向对象的思考，属性，方法等概念在被近几次大作业中得到了很好的消化，对于编程软件（如eclipse和idea）的使用更加熟练，现在可以做到以调试独自解决代码出现的问题。java的学习相比C语言的学习，节奏更加的快，内容很充实，一环扣一环，同时经过一段时间的学习，我自身解决问题能力大大提升。
标签：题目,记录,int,PTA,else,BLOG,flag,&&,菜品 From： https://www.cnblogs.com/nchu-niuhao/p/17429761.html