(1) 前言：
第一次作业：第一次作业的七道题相对来说比较基础，因为这是我们第一次写关于Java的代码，现在回看第一次作业，虽然比较基础，但是对于我来说，第一次作业是学到了比较多的东西的，我也记了一些笔记比如：
1..next()和.nextLine()的区别：.next()如果输入了一串字符，到了有空格的时候就会停止录入，只录入空格前面的东西，空格后面的东西（包括分隔的空格都会保留在缓存区域）除了空格以外，Tab键和Enter键都被视为分隔符（结束符）而.nextLine()返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的；
2.Integer.parseInt的作用：是将整型数据Integer转换为基本数据类型int；
3.当 Scanner input= new Scanner(System.in);了后最好接一个input.close();（虽然不会报错，但是编译器会有警告）
4.如果变量是int类型，读入输入的东西时用nextInt(),其他类型也是这样的规律，double的类型就用nextDouble()等等；
5.强制类型转换 eg：（int）即强制转换成int类型；
6.如果需要读入不止一个，则是这样：Scanner input=new Scanner(System.in);
int m=input.nextInt();
int n=input.nextInt();即可；
7. substring()：截取字符串中介于两个指定下标之间的字符.
eg 字符串.substring(参数1，参数2);
参数1：字符串截取的起始下标，非负的整数，如果此参数是0,则是从字符串的第一个字符开始截取
参数2：截取结束位置的索引下标（如果没有参数2，结束就是字符串末尾的字符串）；
以上大概是我从作业1中发现的知识点，题量对于当时的我来说是足够的，难度适中。
第二次作业：第二次作业有4道题目，可以说是我的噩梦了，这四道题让我对自己进行了深刻的反思，因为前两题我花费了大量的时间但是结果并不是很友好，我才发现我对Java的不熟练，还是对于我来说，第一次作业和第二次作业的难度相差的有点大，不过我还是学到了一些，以下：
1. 四舍五入函数： Math.round()，两次菜单都要用到这个知识点；
2. equals():equals 方法用于检测一个对象是否等于另一个对象，eg在第一题和第二题里
dishName = input.next();
if (dishName.equals("end")) {break; }
3．集合：集合可以存储任意类型的对象，并且长度可变。如我所用到的Map<> menu = new HashMap<>()；
4.split()函数：对字符串以给定的字符进行分隔，得到字符串数组。感觉这个经常用到， . 、 $、 | 和 * 等转义字符，得加\\；多个分隔符，可以用 | 作为连字符；
5. .length：数组长度；
6. LocalDate：对日期的描述的一个类（第三题基本可以用该类里面的方法做）；
这些是我在第二次作业中发现的知识点，当我做第三次作业时，发现这些知识点还是蛮重要的，题目量虽然比第一次作业的量要少，但是难度对于我来说却是大大提升，做的比较艰难，花费了大量的时间；
第三次作业：第三次作业有七道题，但是有了一点之前作业留下的基础，除了第一题（第二次作业的延申）剩下的6题是有思路的有方向的，有几题虽然卡了一段时间，但是都写出来了，下面是我发现的知识点：
1. 数组： Set<String> set=new HashSet<>(); List<String> wordList = new ArrayList<>(wordSet);（第一次作业也用到了，这次再用加深了一些印象）
2. set.size()是数组的大小；
3. 正则表达式的split()方法；
4. 比较器：实现集合中元素的比较、排序（eg Comparator<String> comparator = (s1, s2) ->）；
5. Collections.sort()方法
6. 新的输出方式：for (String word : wordList) {
System.out.println(word); }
7.无参构造方法:eg public Student() {
this("张三"); }
8.有参构造方法
public Student(String name) {
this.name = name; }
9. this关键字的使用：只能在方法内部使用，表示对“调用方法的那个对象”的引用（不能用在static方法中）；
10. LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用；
11.ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法；
12.数组转集合：array转化为List集合，通过Arrays工具类中的asList()方法；集合转化为数组，通过调用集合类中的toArray()方法即可。
这些就是我在做第三次作业记录的知识点，这次作业的题目量还行，但是第一题的难度确实大，一开始测试点全是非零返回和答案错误，不过也得到了提升。
(2)设计与分析
7-1 身体质量指数（BMI）测算 分数 10 作者 蔡轲 单位 南昌航空大学体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。
输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；
输出格式:
输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。
输入样例0:
在这里给出一组输入。例如：
-2 8
输出样例0:
在这里给出相应的输出。例如：
input out of range
输入样例1:
在这里给出一组输入。例如：
70 1.75
输出样例1:
在这里给出相应的输出。例如：
fit
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
double weigh=input.nextDouble();
double high=input.nextDouble();
double bmi=weigh/(high*high);
if(weigh>=727||high>=2.72||weigh<=0||high<=0)
System.out.print("input out of range");
else if(bmi>=18.5&&bmi<24)
System.out.print("fit");
else if(bmi<18.5)
System.out.print("thin");
else if(bmi>=24&&bmi<28)
System.out.print("overweight");
else if(bmi>=28)
System.out.print("fat");
}
}
7-2 有重复的数据
分数 10
作者 翁恺
单位 浙江大学
在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。
输入格式:
你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。
输出格式:
如果这些整数中存在重复的，就输出：
YES
否则，就输出：
NO
输入样例:
5
1 2 3 1 4
输出样例:
YES
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int num= input.nextInt();
input.nextLine();
String[] strings= input.nextLine().split(" ");
Set<String> set=new HashSet<>();
for (int i = 0; i < num; i++) {
set.add(strings[i]);
}
if (set.size()==num) System.out.println("NO");
else System.out.println("YES");
}
}
7-3 去掉重复的数据
分数 10
作者 翁恺
单位 浙江大学
在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，去掉所有重复的数字。最后按照输入顺序输出没有重复数字的数据。所有重复的数字只保留第一次出现的那份。
输入格式:
你的程序首先会读到一个正整数 n，1≤n≤100000。
然后是 n 个整数，这些整数的范围是 [1, 100000]。
输出格式:
在一行中按照输入顺序输出去除重复之后的数据。每两个数据之间有一个空格，行首尾不得有多余空格。
输入样例:
5
1 2 2 1 4
输出样例:
1 2 4
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int num= input.nextInt();
int a[] = new int[100010];
int k =0;
int b[] = new int[100010];
for (int i = 0; i < num; i++) {
int m = input.nextInt();
if(a[m] !=0){
continue;
}
a[m] = 1;
b[k] = m;
k++;
}
for (int i = 0; i < k-1; i++) {
System.out.print(b[i]+" ");
}
System.out.print(b[k-1]);
}
}
7-4 单词统计与排序
分数 15
作者 张峰
单位 山东科技大学
从键盘录入一段英文文本（句子之间的标点符号只包括“,”或“.”，单词之间、单词与标点之间都以" "分割。
要求：按照每个单词的长度由高到低输出各个单词（重复单词只输出一次），如果单词长度相同，则按照单词的首字母顺序（不区分大小写，首字母相同的比较第二个字母，以此类推）升序输出。
输入格式:
一段英文文本。
输出格式:
按照题目要求输出的各个单词（每个单词一行）。
输入样例:
Hello, I am a student from China.
输出样例:
student
China
Hello
from
am
a
I
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String text = scanner.nextLine();
String words[]= text.split("[\\s,.]+");
Set<String> wordSet = new HashSet<>(Arrays.asList(words));
// 比较器
Comparator<String> comparator = (s1, s2) ->
{
if (s1.length() != s2.length()) {
return s2.length() - s1.length();
} else {
return s1.compareToIgnoreCase(s2);
}
};
List<String> wordList = new ArrayList<>(wordSet);
Collections.sort(wordList, comparator);
for (String word : wordList) {
System.out.println(word);
}
}
}
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
48import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Map<String, Integer> menu = new HashMap<>();
Map<Integer, String[]> orders = new HashMap<>();
int orderNum = 0;
int flag=1;
int total=0;
String input = sc.nextLine();
while (!input.equals("end")) {
String[] inputArr = input.split(" ");
if (flag==1&&inputArr.length == 2) {
menu.put(inputArr[0], Integer.parseInt(inputArr[1]));
if(num==)
}
else if (inputArr.length == 4)
{
int num = Integer.parseInt(inputArr[0]);
String name = inputArr[1];
int price = menu.getOrDefault(name, -1);
if (price == -1) {
System.out.println(name + " does not exist");
}
else {
int amount = Integer.parseInt(inputArr[2]);
double i=0;
switch (amount) {
case 1:
i=1;
break;
case 2:
i=1.5;
break;
case 3:
i=2;
break;
}
int count = Integer.parseInt(inputArr[3]);
double totalPrice = price * i * count;
int l=(int)Math.round(totalPrice);
String[] order = new String[]{name, String.valueOf(amount), String.valueOf(count), String.valueOf(l)};
orders.put(num, order);
System.out.println(inputArr[0] + " " + order[0] + " " + order[3]);
total += Integer.parseInt(order[3]);
}flag=0;
}
else {
int num = Integer.parseInt(inputArr[0]);
if (!orders.containsKey(num)) {
// 序号不存在
System.out.println("delete error");
} else {
String[] order = orders.get(num);
total -= Integer.parseInt(order[3]);
orders.remove(num);
}
}
input = sc.nextLine();b
}
// for (int i = 1; i <= orders.size(); i++) {
// String[] order = orders.get(i);
// total += Integer.parseInt(order[3]);
// }
//输出总价
System.out.println(total);
}
}
这道题的代码难度如上图，这道题我运用到了集合 ，代码中的Map<String, Integer> menu = new HashMap<>();Map<Integer, String[]> orders = new HashMap<>();
即集合，选择集合而不是数组是因为虽然数组可以储存多个对象，但在无法确定需要保存多少个对象时，数组将不再适用，因为数组的长度不可变。所以为了保存这些
数目不确定的对象，Java中提供了集合，集合可以存储任意类型的对象，并且长度可变。
菜单计价程序-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
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 菜单
Map<String, Double> menu = new HashMap<>();
while (true) {
String line = sc.nextLine().trim();
if (line.equals("end")) {
break;
}
String[] arr = line.split(" ");
menu.put(arr[0], Double.parseDouble(arr[1]));
}
// 订单
List<Table> tables = new ArrayList<>();
Table currentTable = null;
boolean isOrderFinished = false;
while (!isOrderFinished) {
String line = sc.nextLine().trim();
String[] arr = line.split(" ");
switch (arr[0]) {
case "end":
isOrderFinished = true;
break;
case "table":
if (currentTable != null) {
tables.add(currentTable);
}
int tableNum = Integer.parseInt(arr[1]);
String time = arr[2];
currentTable = new Table(tableNum, time);
break;
case "delete":
if (currentTable == null) {
System.out.println("delete error");
break;
}
int deleteIndex = Integer.parseInt(arr[1]);
if (deleteIndex > currentTable.orderList.size()) {
System.out.println("delete error");
} else {
currentTable.orderList.remove(deleteIndex - 1);
}
break;
default:
if (currentTable == null) {
break;
}
int index = Integer.parseInt(arr[0]);
String dishName = arr[1];
int portion = Integer.parseInt(arr[2]);
int number = Integer.parseInt(arr[3]);
double price = menu.get(dishName);
switch (portion) {
case 1:
price *= 1;
break;
case 2:
price *= 1.5;
break;
case 3:
price *= 2;
break;
}
Order order = new Order(index, dishName, portion, number, price);
currentTable.orderList.add(order);
break;
}
}
if (currentTable != null) {
tables.add(currentTable);
}
// 计算价格并输出结果
for (Table t : tables) {
if (!isInOpeningHours(t.time)) {
System.out.println("table " + t.tableNum + " out of opening hours");
continue;
}
double totalPrice = 0;
for (Order o : t.orderList) {
totalPrice += o.price * o.number;
}
for (Order o : t.otherOrders) {
totalPrice += o.price * o.number;
}
if (isWeekend(t.time)) {
System.out.println("table " + t.tableNum + " " + Math.round(totalPrice));
} else if (isDinnerTime(t.time)) {
System.out.println("table " + t.tableNum + " " + Math.round(totalPrice * 0.8));
} else if (isLunchTime(t.time)) {
System.out.println("table " + t.tableNum + " " + Math.round(totalPrice * 0.6));
} else {
System.out.println("table " + t.tableNum + " out of opening hours");
}
}
}
private static boolean isInOpeningHours(String time) {
int hour = Integer.parseInt(time.substring(0, 2));
int minute = Integer.parseInt(time.substring(3));
if (hour < 9 || hour > 21 || (hour == 21 && minute > 30)) {
return false;
}
if (hour >= 10 && hour <= 14 && minute <= 30) {
return true;
}
if (hour >= 17 && hour <= 20 && minute >= 30) {
return true;
}
return false;
}
private static boolean isWeekend(String time) {
int dayOfWeek = getDayOfWeek(time);
return dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY;
}
private static boolean isLunchTime(String time) {
int hour = Integer.parseInt(time.substring(0, 2));
return hour >= 10 && hour <= 14;
}
private static boolean isDinnerTime(String time) {
int hour = Integer.parseInt(time.substring(0, 2));
return hour >= 17 && hour <= 20;
}
private static int getDayOfWeek(String time) {
int year = Integer.parseInt(time.substring(6, 10));
int month = Integer.parseInt(time.substring(11, 13)) - 1;
int dayOfMonth = Integer.parseInt(time.substring(14, 16));
Calendar cal = Calendar.getInstance();
cal.set(year, month, dayOfMonth);
return cal.get(Calendar.DAY_OF_WEEK);
}
private static class Table {
int tableNum;
String time;
List<Order> orderList;
List<Order> otherOrders;
public Table(int tableNum, String time) {
this.tableNum = tableNum;
this.time = time;
this.orderList = new ArrayList<>();
this.otherOrders = new ArrayList<>();
}
}
private static class Order {
int index;
String dishName;
int portion;
int number;
double price;
public Order(int index, String dishName, int portion, int number, double price) {
this.index = index;
this.dishName = dishName;
this.portion = portion;
this.number = number;
this.price = price;
}
}
}
这道题我还没有研究明白，总是有几个点卡不过去，不过我觉得是哪里{}包括的范围出了问题，或者是顺序什么的，运行没有问题的话我可以加个flag什么的判断一下
类分为菜品类：对应菜谱上一道菜的信息String name;//菜品名称int unit_price; //单价int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信包括了菜品数组，保存所有菜品信息和添加一道菜品信息还有点菜记录类：保存订单上的一道菜品记录包括序号，菜品，份额和
计价，计算本条记录的价格，订单类：保存用户点的所有菜的信息。
7-5 面向对象编程(封装性) 分数 10 作者 蒋辉 单位 天津仁爱学院Student类具体要求如下：
私有成员变量：学号(sid，String类型)，姓名(name，String类型)，年龄(age，int类型)，专业(major，String类型) 。
提供无参构造和有参构造方法。（注意：有参构造方法中需要对年龄大小进行判定）
普通成员方法：print()，输出格式为“学号：6020203100，姓名：王宝强，年龄：21，专业：计算机科学与技术”。
普通成员方法：提供setXxx和getXxx方法。（注意：setAge()方法中需要对年龄进行判定）
注意：
年龄age不大于0，则不进行赋值。
print()中的“：”和“，”为均为中文冒号和逗号。
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
//调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
//对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}
/* 请在这里填写答案 */
输入格式:
无
输出格式:
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程
输入样例:
在这里给出一组输入。例如：
6020203110 王宝强 21 计算机科学与技术
6020203119 张三丰 23 软件工程
输出样例:
在这里给出相应的输出。例如：
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
//调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
//对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}
class Student{
private String sid;
private String name;
private int age;
private String major;
public Student(){}
public Student(String sid,String name,int age,String major){
this.name =name;
this.sid=sid;
this.age=age;
this.major =major;
}
public void setSid (String sid){
this.sid=sid;
}
public String setSid (){
return sid;
}
public String setName() {
return name;
}
public void setName(String name) {
this.name =name;
}
public int setAge() {
return age;
}
public void setAge(int age) {
this.age=age;
}
public String setMajor(){
return major;
}
public void setMajor(String major){
this.major =major;
}
public void print(){
System.out.println("学号"+"："+sid+"，"+"姓名"+"："+name+"，"+"年龄"+"："+age+"，"+"专业"+"："+major);
}
}
7-7 判断两个日期的先后，计算间隔天数、周数
分数 15
作者 吴光生
单位 新余学院
从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。
预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。
输入格式:
输入两行，每行输入一个日期，日期格式如：2022-06-18
输出格式:
第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周
输入样例1:
2000-02-18
2000-03-15
输出样例1:
第一个日期比第二个日期更早
两个日期间隔26天
两个日期间隔3周
输入样例2:
2022-6-18
2022-6-1
输出样例2:
第一个日期比第二个日期更晚
两个日期间隔17天
两个日期间隔2周
import java.util.Scanner;
import java.time.temporal.ChronoUnit;
import java.time.LocalDate;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
String a1=input.nextLine();
String a2=input.nextLine();
String arr1[]=a1.split("-");
String arr2[]=a2.split("-");
int y1=0;
int m1 =0;
int d1 =0;
int y2 =0;
int m2 =0;
int d2 =0;
y1 = Integer.parseInt( arr1[0] );
m1 = Integer.parseInt( arr1[1] );
d1 = Integer.parseInt( arr1[2] );
y2 = Integer.parseInt( arr2[0] );
m2 = Integer.parseInt( arr2[1] );
d2 = Integer.parseInt( arr2[2] );
LocalDate date1 = LocalDate.of(y1, m1, d1);
LocalDate date2 = LocalDate.of(y2, m2, d2);
if(date1.isBefore(date2))
System.out.println("第一个日期比第二个日期更早");
else
System.out.println("第一个日期比第二个日期更晚");
long dayCount = date1.until(date2, ChronoUnit.DAYS);
long weekCount = date1.until(date2, ChronoUnit.WEEKS);
System.out.println("两个日期间隔" + Math.abs(dayCount) + "天" );
System.out.println("两个日期间隔" + Math.abs(weekCount) + "周" );
}
}
（3）采坑心得：当时写一道题的出现了一个问题，卡了好久，不知道问题在哪，查了很多资料，不过得到了解决
后来才发现方法在调用的时候不需要声明类型，只有在创建的时候才需要声明
这么改就行
还有一个比较初级的错误
导致输出是这个
错在输出的时候是单引号了，改成双引号即可，如下
还有是细节问题，switch的一个case对应一个break，有几个case即有几个break，以下这张图是错误的
改成如下即可得到题给答案
还有一个总是报错的点
这个问题就是用括号把amount*1.5括起来就解决啦！
（4）主要困难以及改进建议：
第一次作业主要是巩固基础，可能因为是我们刚刚开始学习Java的缘故吧，题目相对后面几次作业来说相对简单， 所以做起来也比较快，但是收获确实是最多的，不过有很多题
我还是想复杂了，就比如第三题我其实一开始的思路是对的，但是有一点点小问题，好像是有1位数是不同的，当时就觉得奇怪，但也没有深入思考，换了一种方法写，但是后来
回想起来，其实我第一次的做法会更简单，只需要加个强制类型转换就像。
第二次作业在基础的前提下改进了很多，难度也大了不少，这次作业我遇到的困难还是比较多的，就比如Java中数组和集合的使用。尤其是集合，当时老师还没有讲到集合，所以
我就只能不断地查阅资料弄清楚集合的定义，集合与数组的区别在哪，集合如何创建和使用等等，花费了我大量的时间。要说改进的话，就是第一二题，当时我还不太会面向对象，
我是直接面向过程的，因为之前学过c语言，对于面向过程还比较熟悉，现在想来，如果当时我是面向对象，我的第三次作业的那个点菜系统不至于写不出来，所以我觉得如果要改
进的话，我应该用多个类去写代码，还有那个日期的那道题，我还不知道LocalDate那时候，所以花费了很多时间自己写类似于函数的代码，浪费了很多时间，如果要改进，我会直
接使用时间方法。
第三次作业遇到的主要困难是英语单词的那道题中的比较器的使用，我又是去不断地找资料，因为我还不太清楚它到底是如何被使用的，用了好几次要不报错，要不得不到我想要的
答案，最终我还是寻求了专业人士（我哥亲情赞助）帮助，解决了这个问题，不过他说这个其实不用比较器也是比较容易做出来的，我还没有深入的继续思考；还有一个较大的困难
还是点菜系列，由于我前两道点菜的题结束了没有多加思考，导致了一开始这道题我无从下手，不过我现在会吸取教训，好好想想到底是哪里出了问题。
以上，就是我遇到的主要困难与改进建议。
（5）总结：
学会了Java语言的基础知识，在开始Java作业之前必须掌握Java语言的基础知识，包括数据类型、控制结构、类、对象、继承、多态等等，只有掌握了这些基础知识，才能好
好地完成Java作业。Java作业中可能会出现各种各样的异常，需要学会如何处理这些异常还有要熟悉Java开发工具，我用的是Eclipse，因为英文有很多专业名词不太认识，所
以我把它汉化了，使我的操作更加快速方便。在编写Java作业时注重代码结构和质量，例如使用面向对象的设计模式、编写可读性强的代码、遵循代码规范等等。Java作
业需要掌握Java语言的基础知识，熟悉开发工具，注重代码质量和结构，注意异常处理和进行单元测试等方面。每次在作业中遇到无法解决的问题，我都会先在网上搜索资料
和参考资料。在写PTA的过程中我意识到自己代码的可读性十分不高，逻辑性还不够清晰，我应该注重代码书写习惯还有一些小细节。在学习中，我认为自己还有很多不足，虽然
代码是认真敲的，但还是可能会有些部分地方不能理解，尤其在面向对象时代码篇幅较长，出现的错误就比较多，纠正错误是我最害怕的事，我的心态也可能会因为一个错误花费
了大量的时间却依然错误改变很多，所以心态也很重要，心态可以决定很多东西，只要放平心态，有好的心态，我相信没有什么是我们无法解决的。还有就是这个学期的课程比较多
可能对时间上我没有花额外的时间去敲代码感觉没有这么多时间去投入到额外的代码编程中去，因此很少有自己主动编写的程序，但是pta作业的难度和量已经让Java占据了我大部
分的时间，也许是我的技术还是有待提高，所以我会继续努力，遇到不会的知识点会不断地从网上查找资料，请教同学和老师，不断进步！
。
标签：输出,String,记录,int,BLOG,菜品,输入 From： https://www.cnblogs.com/xxx10171125/p/17277022.html