前三次作业总结
一、前言
1、知识点：前两次作业的知识点并不多，主要是对与java中一些语法、逻辑及类的创建的一些考察，还有哈希表的使用，第三次作业考察的知识点主要是java中一些常用API的使用，例如time。
2、题量：题量不算太多，逐渐在减少，但是难度在一点一点的增加，测试点难找。
3、难度：前两次的难度都不算太大，第三次有些题目难度稍微增加。
二、设计与分析
第一次作业
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
代码如下：
import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner input=new Scanner(System.in); double a=input.nextDouble(); double b=input.nextDouble(); double c=input.nextDouble(); if(a<1||a>200||b<1||b>200||c<1||c>200){ System.out.println("Wrong Format"); return; } if(a+b<=c||a+c<=b||b+c<=a){ System.out.println("Not a triangle"); return; } else{ if(a==b&&b==c){ System.out.println("Equilateral triangle"); return; } if((a==b||b==c||a==c)&&(a*a+b*b-c*c<0.0001||b*b+c*c-a*a<0.00001||a*a+c*c-b*b<0.00001)){ System.out.println("Isosceles right-angled triangle"); return; } if((a*a+b*b!=c*c&&b*b+c*c!=a*a&&a*a+c*c!=b*b)&&(a==b||b==c||a==c)){ System.out.printf("Isosceles triangle"); return; } if((a*a+b*b-c*c<0.00001||b*b+c*c-a*a<0.00001||a*a+c*c-b*b<0.00001)&&(a!=b&&b!=c&&a!=c)){ System.out.printf("Right-angled triangle"); return; } System.out.printf("General triangle"); return; } } }
分析：
这道题目虽然不难，倒是这个测试点是真的找不到，后来也是在网上找到了解决方法，这道题目在判断直角三角形时，即a*a+b*b=c*c时，如果两个的差值，如a*a+b*b-c*c<0.0001，它也算作直角三角形，所以这个测试点有点难找，上面的代码判断条件写的有点复杂，其实也可以简化，我这里就没有简化。
第二次作业
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 80 80 80 22201312 黄昊 66 82 81 22201313 李少辰 77 76 80 22201314 袁婷 62 79 90 22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 240 80.00 22201312 黄昊 229 76.33 22201313 李少辰 233 77.67 22201314 袁婷 231 77.00 22201315 朱哲一 266 88.67
代码如下：
import java.util.Scanner; public class Main { public static void main(String[] args) { Student []stu= new Student[5]; double total=0; double average=0; int []scores=new int[3]; Scanner input = new Scanner(System.in); for(int i=0;i<5;i++){ String IDNum = input.next(); String name = input.next(); for(int j=0;j<3;j++){ scores[j]= input.nextInt(); total+=scores[j]; } average=total/3; stu[i]= new Student(IDNum,name,scores,average,total); total=0; } for(int i=0;i<5;i++){ System.out.print(stu[i].IDNum+" "+stu[i].name+" "+(int)stu[i].total+" "); System.out.println(String.format("%.2f", stu[i].average)); } } public static class Student { String IDNum; String name; int []scores; double average; double total; public Student(String IDNum, String name, int []scores,double average,double total) { this.IDNum = IDNum; this.name = name; this.scores = scores; this.average=average; this.total=total; } } }
分析：这道题就不多说了，唯一要注意的就是后面输出的问题，要求保留小数点后两位输出，上面的链接供参考。
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 语文 70 80 22201311 张琳 数学 85 89 22201311 张琳 物理 75 83 22201312 黄昊 语文 66 78 22201312 黄昊 数学 76 82 22201312 黄昊 物理 83 82 22201313 李少辰 语文 86 76 22201313 李少辰 数学 78 76 22201313 李少辰 物理 87 76
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67 22201312 黄昊 234 75.00 80.67 78.00 22201313 李少辰 236 83.67 76.00 78.67
代码如下：
import java.util.Scanner; public class Main { public static void main(String[] args) { Student []stu= new Student[3]; double total=0; double all_average=0; double pinshi_average; double qimou_average; double pinshi_total=0; double qimou_total=0; double all_total=0; int []scores=new int[2]; Scanner input = new Scanner(System.in); for(int i=0;i<9;i++){ String IDNum = input.next(); String name = input.next(); String subject=input.next(); for(int j=0;j<2;j++){ scores[j]= input.nextInt(); } pinshi_total+=scores[0]; qimou_total+=scores[1]; total=(int)(0.4*scores[0]+0.6*scores[1]); all_total+=total; if(i==2){ pinshi_average=pinshi_total/3; qimou_average=qimou_total/3; all_average=all_total/3; stu[0]= new Student(IDNum,name,scores,pinshi_average,qimou_average,all_average,all_total); pinshi_total=0; qimou_total=0; all_total=0; } if(i==5){ pinshi_average=pinshi_total/3; qimou_average=qimou_total/3; all_average=all_total/3; stu[1]= new Student(IDNum,name,scores,pinshi_average,qimou_average,all_average,all_total); pinshi_total=0; qimou_total=0; all_total=0; } if(i==8){ pinshi_average=pinshi_total/3; qimou_average=qimou_total/3; all_average=all_total/3; stu[2]= new Student(IDNum,name,scores,pinshi_average,qimou_average,all_average,all_total); pinshi_total=0; qimou_total=0; all_total=0; } total=0; } for(int i=0;i<3;i++){ System.out.print(stu[i].IDNum+" "+stu[i].name+" "+(int)stu[i].total+" "); System.out.println(String.format("%.2f", stu[i].pinshi_average)+" "+String.format("%.2f", stu[i].qimou_average) +" "+String.format("%.2f", stu[i].all_average)); } } public static class Student { String IDNum; String name; int []scores; double pinshi_average; double qimou_average; double all_average; double total; public Student(String IDNum, String name, int []scores,double pinshi_average,double qimou_average,double all_average,double total) { this.IDNum = IDNum; this.name = name; this.scores = scores; this.pinshi_average=pinshi_average; this.qimou_average=qimou_average; this.all_average=all_average; this.total=total; } } }
分析：这道题也没什么可说的，无非就是7-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 Main{ public static void main(String[] args){ Dish[] dishes={ new Dish("西红柿炒蛋", 15), new Dish("清炒土豆丝", 12), new Dish("麻婆豆腐", 12), new Dish("油淋生菜", 9) }; Menu menu=new Menu(dishes); Order order=new Order(); order.records=new Record[100]; // 假设订单最多有100道菜 // 读入订单信息 Scanner scanner=new Scanner(System.in); int count=0; while(true){ String input=scanner.nextLine(); if (input.equals("end")){ break; } String[] parts=input.split(" "); String dishName=parts[0]; int portion=Integer.parseInt(parts[1]); Record record=order.addARecord(dishName,portion,menu); if (record!=null){ order.records[count]=record; count++; } } // 输出订单总价 int totalPrice=order.getTotalPrice(); System.out.println(totalPrice); } public static class Dish{ String name; int unit_price; public Dish(String name, int unit_price) { this.name=name; this.unit_price=unit_price; } public int getPrice(int portion) { double price=0; switch (portion){ case 1: price=unit_price; break; case 2: price=unit_price * 1.5; break; case 3: price=unit_price * 2; break; default: break; } return (int)(Math.round(price)); } } public static class Menu{ Dish[] dishes; public Menu(Dish[] dishes){ this.dishes=dishes; } public Dish searchDish(String dishName){ for (Dish dish : dishes){ if (dish.name.equals(dishName)){ return dish; } } return null; } } public static class Record { Dish dish; int portion; public Record(Dish dish,int portion){ this.dish=dish; this.portion=portion; } public int getPrice() { return dish.getPrice(portion); } } public static class Order { Record[] records; public Order(){ records=new Record[100]; } public Record addARecord(String dishName, int portion, Menu menu) { Dish dish = menu.searchDish(dishName); if (dish != null) { Record record = new Record(dish, portion); records[getNumberOfRecords()] = record; } else { System.out.println(dishName + " does not exist"); return null; } return null; } public int getNumberOfRecords() { int count = 0; for (int i = 0; i < records.length; i++) { if (records[i] == null) { break; } count++; } return count; } public int getTotalPrice(){ int totalPrice=0; for (Record record : records){ if (record==null) { break; } totalPrice+=record.getPrice(); } return totalPrice; } } }
分析：这道题的关键是如何去匹配菜单中存在的菜品和判断记录客人以点菜品和记录菜品中是否有重复，去除重复的情况，如果菜品中不存在顾客点的菜品则输出异常情况，这道题吧，虽然说不算难，但是这道题的难点是整个框架的搭建，比如，如何创建类，类里面包含了哪些属性及方法，还有就是逻辑的正确性，所以写题目前，捋清楚题目的逻辑是很重要的。
- 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
- 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"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,不合法!
代码如下：
import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner scanner = new Scanner(System.in); Date[] dates = new Date[3]; String date; for(int i = 0;i < 3;i++) { dates[i] = new Date(); date = scanner.next(); dates[i].setDate(date);; } if(!dates[0].judge()) { System.out.println(dates[0].getDate() + "无效!"); } else { int year = Integer.parseInt(dates[0].getDate().substring(0,4)); int month = Integer.parseInt(dates[0].getDate().substring(5,7)); int day = Integer.parseInt(dates[0].getDate().substring(8,10)); if(dates[0].isleap(year)) { System.out.println(dates[0].getDate() + "是闰年."); } System.out.println(dates[0].getDate() + "是当年第" + dates[0].getDayOfyear(year,month,day)+"天,当月第" + dates[0].getDayOfmonth(day) + "天,当周第" + dates[0].getDayOfweek(year,month,day) + "天."); } if(dates[1].judge()&&dates[2].judge()) { int year = Integer.parseInt(dates[1].getDate().substring(0, 4)); int month = Integer.parseInt(dates[1].getDate().substring(5, 7)); int day = Integer.parseInt(dates[1].getDate().substring(8, 10)); int year1 = Integer.parseInt(dates[2].getDate().substring(0, 4)); int month1 = Integer.parseInt(dates[2].getDate().substring(5, 7)); int day1 = Integer.parseInt(dates[2].getDate().substring(8, 10)); if (year > year1) { System.out.print(dates[2].getDate() + "早于" + dates[1].getDate() + ",不合法!"); }else if (year == year1 && month > month1) { System.out.print(dates[2].getDate() + "早于" + dates[1].getDate() + ",不合法!"); }else if (year == year1 && month == month1 && day > day1) { System.out.print(dates[2].getDate() + "早于" + dates[1].getDate() + ",不合法!"); }else { int year2; int month2; int day2; year2 = year1 - year; month2 = month1 - month; day2 = dates[2].accountDay() - dates[1].accountDay(); System.out.print(dates[2].getDate() + "与" + dates[1].getDate() + "之间相差" + day2 + "天,所在月份相差" + month2 + ",所在年份相差" + year2 + "."); } } else{ System.out.print(dates[1].getDate() + "或" + dates[2].getDate() + "中有不合法的日期."); } } public static class Date{ String Day; public void setDate(String date) { this.Day=date; } public String getDate() { return Day; } public boolean judge(){ boolean legal=legalJudgment(Day); if(legal){ int year=Integer.parseInt(Day.substring(0,4)); int month=Integer.parseInt(Day.substring(5,7)); int day=Integer.parseInt(Day.substring(8,10)); boolean leap=isleap(year); if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)) { return day >= 1 && day <= 31; } else if ((month == 4 || month == 6 || month == 9 || month == 11)) { return day >= 1 && day <= 30; } else if (month == 2) { if (leap) { if (day >= 1 && day <= 29) return true; return false; } else { if (day >= 1 && day <= 28) return true; return false; } } return false; } return false; } public int getDayOfyear(int year,int month,int day){ int total=0; int []arr1={31,29,31,30,31,30,31,31,30,31,30,31}; int []arr2={31,28,31,30,31,30,31,31,30,31,30,31}; if(isleap(year)){ if(month==1) return arr1[0]-day; else{ for(int i=0;i<month-1;i++){ total+=arr1[i]; } return total+day; } } else{ if(month==1) return arr2[0]-day; else{ for(int i=0;i<month-1;i++){ total+=arr2[i]; } return total+day; } } } public int getDayOfmonth(int day){ return day; } public int getDayOfweek(int year,int month,int day){ int totalDays = 0; int num_day=getDayOfyear(year, month, day); // 获取基准日期的星期几（1973年1月1日是星期一） int dayOfWeekEpoch = 0; // 计算给定日期是当周的星期几 for(int i=1973;i<year;i++){ if(i % 4 == 0 && i % 100 != 0 || i % 400 == 0) totalDays+=366; else totalDays+=365; } int dayOfWeek = (dayOfWeekEpoch + totalDays+num_day) % 7; // 调整为星期一到星期日对应的值（1到7） dayOfWeek = (dayOfWeek == 0) ? 7 : dayOfWeek; return dayOfWeek; } public boolean isleap(int year){ if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) return true; return false; } public int accountDay(){ int year = Integer.parseInt(Day.substring(0,4)); int month = Integer.parseInt(Day.substring(5,7)); int day = Integer.parseInt(Day.substring(8,10)); int total = 0; int[] arr= {0,31,28,31,30,31,30,31,31,30,31,30,31}; for(int i = 1;i < year;i++) if(i % 4 == 0 && i % 100 != 0 || i % 400 == 0) total += 366; else total += 365; if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) arr[2] = 29; for(int j = 1;j < month;j++) total += arr[j]; total += day; return total; } public static boolean legalJudgment(String date) { if((date.charAt(0) >= 48 && date.charAt(0) <= 57) && (date.charAt(1) >= 48 && date.charAt(1) <= 57) && (date.charAt(2) >= 48 && date.charAt(2) <= 57) && (date.charAt(3) >= 48 && date.charAt(3) <= 57) && (date.charAt(4) == '-' ) && (date.charAt(5) >= 48 && date.charAt(5) <= 57) && (date.charAt(6) >= 48 && date.charAt(6) <= 57) && (date.charAt(7) == '-') && (date.charAt(8) >= 48 && date.charAt(8) <= 57) && (date.charAt(9) >= 48 && date.charAt(9) <= 57)){ return true; } return false; } } }
分析：这道题目其实并不难，但是我一开始并不知道有关于日期类的库可以直接用，所以就傻呼呼的用常规方法硬写出来的，后面还有一道类似的题，那是用了库的，很方便，说说这道题吧，如果用常规方法，主要有几个测试点要注意，就是他要判断输入日期的合法性，一开始我就是没有考虑数字里面假如有字母，中间那条-如果是其他的字符或数字也算是不合法的输入，所以这个测试点，我也找了很久，最后是同学告诉我的，如果用笨方法，则每位的数字和字符都要去判断，所以这种方法很不方便，导致代码量也多。
第三次作业
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
输入样例1:
仅有课程。例如：
java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet
输入样例2:
单门考试课程 单个学生。例如：
java 必修 考试 20201103 张三 java 20 40 end
输出样例2:
在这里给出相应的输出。例如：
20201103 张三 34
java 20 40 34
202011 34
输入样例3:
单门考察课程 单个学生。例如：
java 选修 考察 20201103 张三 java 40 end
输出样例3:
在这里给出相应的输出。例如：
20201103 张三 40
java 40 40
202011 40
输入样例4:
考试课程 单个学生 不匹配的考核方式。例如：
java 必修 考试 20201103 张三 java 20 end
输出样例4:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch 20201103 张三 did not take any exams java has no grades yet 202011 has no grades yet
输入样例5:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
java 必修 考察 20201103 张三 java 40 end
输出样例5:
在这里给出相应的输出。例如：
java : course type & access mode mismatch java does not exist 20201103 张三 did not take any exams 202011 has no grades yet
输入样例6:
单门课程，多个学生。例如：
java 选修 考察 20201103 李四 java 60 20201104 王五 java 60 20201101 张三 java 40 end
输出样例6:
在这里给出相应的输出。例如：
20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53
输入样例7:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
形式与政治 必修 考试 数据库 选修 考试 java 选修 考察 数据结构 选修 考察 20201103 李四 数据结构 70 20201103 李四 形式与政治 80 90 20201103 李四 java 60 20201103 李四 数据库 70 78 end
输出样例7:
在这里给出相应的输出。例如：
20201103 李四 73 java 60 60 数据结构 70 70 数据库 70 78 75 形式与政治 80 90 87 202011 73
输入样例8:
单门课程，单个学生，成绩越界。例如：
数据结构 选修 考察 20201103 李四 数据结构 101 end
输出样例8:
在这里给出相应的输出。例如：
wrong format
数据结构 has no grades yet
输入样例9:
多门课程，多个学生，多个成绩。例如：
形式与政治 必修 考试 数据库 选修 考试 java 选修 考察 数据结构 选修 考察 20201205 李四 数据结构 70 20201103 李四 形式与政治 80 90 20201102 王五 java 60 20201211 张三 数据库 70 78 end
输出样例9:
在这里给出相应的输出。例如：
20201102 王五 60 20201103 李四 87 20201205 李四 70 20201211 张三 75 java 60 60 数据结构 70 70 数据库 70 78 75 形式与政治 80 90 87 202011 73 202012 72
代码如下：
import java.text.Collator; import java.util.*; public class Main { public static void main(String[] args){ Scanner input=new Scanner(System.in); String message = input.nextLine(); inputHandle InputHandle=new inputHandle(); while (!message.equals("end")){ InputHandle.isLegalInput(message); message=input.nextLine(); } InputHandle.outputStudents(); InputHandle.outputCourses(); InputHandle.outputClasses(); } } class chooseCourse{ Course course; Student student; Scores scores; public chooseCourse(Course course,Student student,Scores scores) { this.course = course; this.student=student; this.scores=scores; } } class Course implements Comparable<Course>{ String courseName; String courseType; String testType; public Course() { } public Course(String courseName,String courseType,String testType) { this.courseName=courseName; this.courseType=courseType; this.testType=testType; } public String getCourseName(){ return courseName; } public String getCourseType(){ return courseType; } public String getTestType(){ return testType; } public int compareTo(Course course) { Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA); return compare.compare(courseName,course.getCourseName()); } } class Student implements Comparable<Student> { String IDNum; String name; String ClassId; public Student(String IDNum, String name,String ClassId) { this.IDNum = IDNum; this.name = name; this.ClassId = ClassId; } public String getName() { return name; } public String getIDNum() { return IDNum; } public String getClassId() { return ClassId; } public int compareTo(Student message) { return this.IDNum.compareTo(message.IDNum); } } class Class implements Comparable<Class> { String ClassId; public Class(String ClassId) { this.ClassId = ClassId; } public String getClassId() { return ClassId; } public int compareTo(Class message) { return this.ClassId.compareTo(message.ClassId); } } class Scores{ int usualScore; int finalScore; public int getUsualScore() { return usualScore; } public int getFinalScore() { return finalScore; } public int getTotalGrade() { return (int) (0.3 * usualScore + 0.7 * finalScore); } } class inputHandle{ ArrayList<Student> listStudent=new ArrayList<>(); ArrayList<Course> listCourse=new ArrayList<>(); ArrayList<Class> listClass=new ArrayList<>(); ArrayList<chooseCourse> listChooseCourse=new ArrayList<>(); public void isLegalInput(String message){ inputCompare compare=new inputCompare(); int legal=compare.InputCompare(message); if(legal==0){ System.out.println("wrong format"); } else if(legal==1) { courseMessage(message); } else if(legal==2){ studentMessage(message); } } public void studentMessage(String str) { String []studentData=str.split(" "); String IDNum=studentData[0]; String ClassId=studentData[0].substring(0,6); String name=studentData[1]; String courseName=studentData[2]; if(searchClass(ClassId)==null){ Class cl=new Class(ClassId); listClass.add(cl); } Student student=new Student(IDNum,name,ClassId); if(!searchStudent(IDNum)){ listStudent.add(student); } if (searchCourse(courseName)==null){ System.out.println(courseName+" does not exist"); }else{ Course course=searchCourse(courseName); if(course.testType.equals("考察")&&studentData.length==4){ Scores scores=new Scores(); scores.finalScore=Integer.parseInt(studentData[3]); chooseCourse ChooseCourse= new chooseCourse(course,student,scores); if(!searchChooseCourse(name,courseName)){ listChooseCourse.add(ChooseCourse); } }else if(studentData.length==5&&course.testType.equals("考察")){ Scores scores=new Scores(); scores.usualScore=Integer.parseInt(studentData[3]); scores.finalScore=Integer.parseInt(studentData[4]); chooseCourse ChooseCourse=new chooseCourse(course,student,scores); if (!searchChooseCourse(name,courseName)){ listChooseCourse.add(ChooseCourse); } }else System.out.println(IDNum+" "+name+" : access mode mismatch"); } } public void courseMessage(String str) { String []courseData=str.split(" "); String courseName=courseData[0]; String courseType=courseData[1]; String testType=courseData[2]; Course course=new Course(courseName,courseType,testType); if(checkCourse(course)){ if(searchCourse(courseName)==null) listCourse.add(course); } } public boolean checkCourse(Course course){ int flag1=0,flag2=0; if(course.courseType.equals("必修")){ flag1=1; }else if(course.courseType.equals("选修")){ flag1=2; } if(course.testType.equals("考试")){ flag2=1; }else if(course.testType.equals("考察")){ flag2=2; } if(flag1==1&&flag2==1) return true; if(flag1==2&&(flag2==1||flag2==2)) return true; System.out.println(course.getCourseName()+" : course type & access mode mismatch"); return false; } public Class searchClass(String ClassId){ for(Class cl:listClass){ if(cl.ClassId.equals(ClassId)) return cl; } return null; } public Course searchCourse(String name){ for(Course course:listCourse){ if(course.getCourseName().equals(name)) return course; } return null; } public boolean searchStudent(String Id){ for(Student stu:listStudent){ if(stu.getIDNum().equals(Id)) return true; } return false; } public boolean searchChooseCourse(String name,String courseName){ for(chooseCourse cs:listChooseCourse){ if(cs.student.getName().equals(name)&&cs.course.getCourseName().equals(courseName)) return true; } return false; } public void outputStudents(){ Collections.sort(listStudent); for (Student stu : listStudent) { ArrayList<chooseCourse> stuCourseSelects = getStudentSelects(stu.getIDNum()); if (!stuCourseSelects.isEmpty()) { System.out.println(stu.getIDNum() + " " + stu.getName() + " " + getAvgTotalScore(stuCourseSelects)); } else System.out.println(stu.getIDNum() + " " + stu.getName() + " " + "did not take any exams"); } } public void outputCourses(){ Collections.sort(listCourse); for (Course course : listCourse) { ArrayList<chooseCourse> stuCourseSelects = getCourseSelects(course.getCourseName()); if (!stuCourseSelects.isEmpty()) { if (course.testType.equals("考试")) System.out.println(course.getCourseName() + " " + getAvgUsualScore(stuCourseSelects) + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects)); if (course.testType.equals("考察")) System.out.println(course.getCourseName() + " " + getAvgFinalScore(stuCourseSelects) + " " +getAvgFinalScore(stuCourseSelects)); } else System.out.println(course.courseName + " " + "has no grades yet"); } } public void outputClasses(){ Collections.sort(listClass); for (Class cla : listClass) { ArrayList<chooseCourse> stuCourseSelects = getClassSelects(cla.getClassId()); if (!stuCourseSelects.isEmpty()) { System.out.println(cla.getClassId() + " " + getAvgTotalScore(stuCourseSelects)); } else System.out.println(cla.getClassId() + " " + "has no grades yet"); } } public ArrayList<chooseCourse> getStudentSelects(String id){ ArrayList<chooseCourse> choose=new ArrayList<>(); for(chooseCourse select:listChooseCourse) { if (select.student.getIDNum().equals(id)) choose.add(select); } return choose; } public ArrayList<chooseCourse> getCourseSelects(String courseName){ ArrayList<chooseCourse> choose=new ArrayList<>(); for(chooseCourse cos:listChooseCourse) { if (cos.course.getCourseName().equals(courseName)) choose.add(cos); } return choose; } public ArrayList<chooseCourse> getClassSelects(String ClassId){ ArrayList<chooseCourse> choose =new ArrayList<>(); for(chooseCourse cos:listChooseCourse) { if (cos.student.getClassId().equals(ClassId)) choose.add(cos); } return choose; } public int getAvgTotalScore(ArrayList<chooseCourse> record){ int average=0; int sum=0; for(chooseCourse c:record){ sum+=c.scores.getTotalGrade(); } average=sum/record.size(); return average; } int getAvgFinalScore(ArrayList<chooseCourse> selects) { int average=0; int sum=0; for(chooseCourse c:selects){ sum+=c.scores.finalScore; } average=sum/selects.size(); return average; } public int getAvgUsualScore(ArrayList<chooseCourse> choose){ int average=0; int sum=0; for(chooseCourse c:choose){ if(c.course.getTestType().equals("考试")){ sum+=c.scores.getUsualScore(); } } average=sum/choose.size(); return average; } } class inputCompare { public inputCompare() { } public boolean courseCompare(String s) { return s.matches("^\\S{1,10} (选修|必修) (考试|考察)$"); } public boolean studentCompare(String s) { //System.out.println(match); return s.matches("^[0-9]{8} \\S{1,10} \\S{1,10} ([1-9]?[0-9]|100)$") || s.matches("^[0-9]{8} \\S{1,10} \\S{1,10} ([1-9]?[0-9]|100) ([1-9]?[0-9]|100)$"); } public int InputCompare(String message) { if (courseCompare(message)) return 1; if (studentCompare(message)) return 2; return 0; } }
分析：这道题可能对于我来说难度有点大，所以我这道题也只得到了一点分，说说我对这道题的理解，这道题的难点我感觉是框架的搭建，如何去判断输入的合法性和如何去存储学生，选课，课程的信息，框架包括类，类的属性，方法，这些老师已经给出了相应的类图，稍微比较简单点，对于输入的合法性，我采用的是正则表达式来判断，这样是比较方便的，存储学生等各种信息的话我利用的是
ArrayList<Student> listStudent=new ArrayList<>();
ArrayList<Course> listCourse=new ArrayList<>();
ArrayList<Class> listClass=new ArrayList<>();
其实吧，我一开始并没有看懂这些方法，后来明白它是将所有的信息存到一个可变数组当中,ArrayList`是 Java 中的一个常用集合类，其内部实现是基于数组的，可以通过下标来访问和修改其中的元素。在操作 `ArrayList` 时，如果我们向其中添加的元素个数超过了已分配的数组长度，则需要对数组进行扩容。这也是 `ArrayList` 能够自动扩容的原因,所以这道题我并没有写出来，上面的代码还有很多测试点没有通过，这道题目老师给的类图里面有一个类继承的问题，这个我还没学，所以也不是很理解，还有一个就是它要求按照字母顺序输出，可以用Comparator这个库函数，这道题我没能写出来，希望以后这种系列题能写出来吧。
从键盘输入两个日期，格式如：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.time.temporal.ChronoUnit; import java.util.Scanner; import java.time.LocalDate; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); Date[] dates = new Date[2]; String date; for(int i = 0;i < 2;i++) { dates[i] = new Date(); date =input.next(); dates[i].setDate(date); } if(dates[0].judgeLegal()&&dates[1].judgeLegal()) { LocalDate date1 = LocalDate.of(dates[0].getYear(),dates[0].getMonth(),dates[0].getDay()); LocalDate date2 = LocalDate.of(dates[1].getYear(),dates[1].getMonth(),dates[1].getDay()); if (date1.isBefore(date2)){ System.out.println("第一个日期比第二个日期更早"); } else if (date1.isAfter(date2)) { System.out.println("第一个日期比第二个日期更晚"); } else { System.out.println("两个日期相同"); return; } long days = date1.until(date2, ChronoUnit.DAYS); long weeks = date1.until(date2, ChronoUnit.WEEKS); System.out.println("两个日期间隔" + Math.abs(days) + "天"); System.out.println("两个日期间隔" + Math.abs(weeks) + "周"); } } static class Date { String date; int year; int month; int day; public void setDate(String date) { this.date = date; } public String getDate() { return date; } public void setDay(int day) { this.day = day; } public void setMonth(int month) { this.month = month; } public void setYear(int year) { this.year = year; } public int getDay() { return day; } public int getMonth() { return month; } public int getYear() { return year; } public boolean judgeLegal() { String[] s=date.split("-"); int year = Integer.parseInt(s[0]); int month = Integer.parseInt(s[1]); int day = Integer.parseInt(s[2]); setYear(year); setMonth(month); setDay(day); //System.out.println(year+" "+month+" "+day); boolean leap = isLeap(year); if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)) { return day >= 1 && day <= 31; } else if ((month == 4 || month == 6 || month == 9 || month == 11)) { return day >= 1 && day <= 30; } else if (month == 2) { if (leap) { if (day >= 1 && day <= 29) return true; return false; } else { if (day >= 1 && day <= 28) return true; return false; } } return false; } public boolean isLeap(int year) { if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) return true; return false; } } }
分析：这道题就比我之前说的用笨方法写的那道题简洁得多，用了import java.time.LocalDate;和import java.time.temporal.ChronoUnit;有了这些库方便太多了
，但是LccalDate在使用时，对于这道题来说，有一个小bug,他输入的要求格式是“2023-09-08”，但题目有一个测试点是“2022-6-18”，所以这就会出问题，我的解决方法是，把他们分别单独取出来获取毫秒数来判断大小
这样就解决了输入格式引起的bug，所以利用库的话，这是个关键点。
三、踩坑心得
- 应该多给代码标上备注。有些题目的类能直接用，但是相隔时间太远，导致我对之前的代码没什么记忆，又没有注释，让我读起来还需要仔细回忆一下这些东西都是干什么的，浪费了很多时间，也感到了注释的重要性。
- 先想好逻辑建构和类图，这至关重要，先把类图构建好，逻辑理顺，这对后面代码的编写有很大的帮助。
- debug是改代码的关键。
- 异常情况的处理很重要，这是很多题目分值的得分点，包括输入格式等等。
四、主要困难和改进意见
1.困难主要在于对类的创建，类的属性，方法的构建，还有一写方便的，常见的API的使用不熟练，还有就是逻辑的循序，这也非常重要，如果逻辑性不强，后面的代码可能你写着写着就不知道自己在写什么。
2.多跟同学交流，多参考网上别人写的优秀的代码，学习别人构建类的方法和学习他们对处理一个问题的逻辑的搭建，一定要捋清楚题目的逻辑。
3.题目的测试点有些是真的很难找，这个可以参考网上别人通过了的代码。
五、总结
总的来说，我的编程能力还有很大的提升空间，这几次的作业相对难度都不算很大，但是我有几道题，也没能完全写出来，都是参考了别人的代码才能勉强得分，这几次是老师给出了类图，对于我们来说，难度减小了不少，
所以好的类的创建，对于我们编写代码会有很大的帮助，java也非常注重逻辑，所以在下次写代码之前一定要捋清题目逻辑并确定一个合适的类与类的关系是至关重要的，这也是我需要学习和提高的地方。
浙公网安备 33010602011771号