java第一次博客作业
前言：
第一次题目集作为第一次PTA的作业，相对而言比较简单，但是最后一题7-7 判断三角形类型有些许弯绕，刚开始并未得到满分，后面经过修改成功拿下
第二次题目集也不是很难，前面一些都是上课或多或少提到过的一些相关知识
第三次题目集开始就有难度了，第一题日期类的题目，利用一些java原本的库函数倒是容易写出，三四题也体量较小，但是第二题题目很多，要求也很多，其所需要写的代码也很多，很容易绕晕，其中层层关系需要细细梳理。第二题过于复杂所以我没有得到满分
设计与分析
第一次作业：7-7 判断三角形类型
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner in = new Scanner(System.in); 5 double a=in.nextDouble(); 6 double b=in.nextDouble(); 7 double c=in.nextDouble(); 8 //是否合法 9 //合法 10 if(a>=1&&a<=200&&b>=1&&b<=200&&c>=1&&c<=200) 11 { 12 //是否为三角形 13 //为三角形 14 if(a+b>c&&a+c>b&&b+c>a) 15 { 16 //是否为等边三角形 17 //是等边三角形 18 if(a==b&&b==c) 19 System.out.println("Equilateral triangle"); 20 //不是等边三角形 21 else 22 { 23 //是否等腰 24 //等腰直角和等腰 25 if((a==b)||(b==c)|(a==c)) 26 { 27 //是否直角 28 //等腰直角 29 if((a*a+b*b-c*c<0.1)||(a*a+c*c-b*b<0.1)||(b*b+c*c-a*a<0.1))//不要用a*a+b*b==c*c 30 System.out.println("Isosceles right-angled triangle"); 31 //等腰非直角 32 else 33 System.out.println("Isosceles triangle"); 34 } 35 //非等腰 36 else 37 { 38 //是否直角 39 //是直角 40 if((a*a+b*b-c*c<0.1)||(a*a+c*c-b*b<0.1)||(b*b+c*c-a*a<0.1)) 41 System.out.println("Right-angled triangle"); 42 //不是直角 43 else 44 System.out.println("General triangle"); 45 } 46 } 47 } 48 //不是三角形 49 else 50 System.out.println("Not a triangle"); 51 } 52 //非法 53 else 54 System.out.println("Wrong Format"); 55 } 56 }
代码解析
刚开始并未使用if嵌套结构，而是分开来判断，结果在PTA上运行时，等腰直角三角形这个测试点无法通过，后面我修改了整体框架代码，使判断逻辑修改为：数值是否合法--->是否是三角形
--->是不是等边三角形--->是否等腰直角--->是否直角。
但是，在判断三角形是否为直角三角形时，一般会使用勾股定理，即判断 a^2 + b^2 是否等于 c^2。然而，在实际计算机编程中，由于浮点数的精度限制，我们不能直接使用等号判断浮点数是否相等。相反，我们可以使用一个较小的误差范围，如0.1，来判断两个浮点数之间的差值是否在这个误差范围内，以解决精度问题。
所以，判断条件 (a*a+b*b-c*c<0.1) || (a*a+c*c-b*b<0.1) || (b*b+c*c-a*a<0.1) 的作用是判断三条边的平方和与最长边的平方之差是否在0.1的误差范围内。如果是，则可以认为三角形是一个近似的直角三角形。
需要注意的是，选择误差范围时应根据具体的应用场景和精度要求进行调整。对于一些精确度要求较高的情况，可能需要使用更小的误差范围。
第二次作业：7-1 成绩计算-1-类、数组的基本运用
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
注意：未用学生类对象封装数据的，本题计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) { Scanner input = new Scanner(System.in); student[] stu = new student[5]; for(int i=0;i<5;i++){ stu[i] = new student(); stu[i].xuehao = input.next(); stu[i].xingming = input.next(); stu[i].yuwen = Integer.parseInt(input.next()); stu[i].math = Integer.parseInt(input.next()); stu[i].wuli = Integer.parseInt(input.next()); } for(int i=0;i<5;i++) stu[i].shuchu(stu[i]); } public static class student{ String xuehao; String xingming; int yuwen; int math; int wuli; int getsum(){ return yuwen+math+wuli; } public void shuchu(student p){ int a; a=getsum(); // double b; b=(double)(a/3); String b =String.format("%.2f",a/3D); System.out.println(this.xuehao+" "+this.xingming+" "+a+" "+b); } } }
代码解析
先创建一个学生类，然后再数组中接收到五个学生信息存进去，然后利用a/3D就可以实现精确到小数点后两位（舍去部分按四舍五入规则计入最后一位）。
"%.2f即是保留两位小数的意思，可以利用这个来达到题目保留两位小数的功能
7-2 成绩计算-2-关联类
创建成绩类，包含：
属性：平时成绩（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.Objects; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); student[] stu = new student[3]; int j=0; int k=0; stu[0] = new student(); stu[1] = new student(); stu[2] = new student(); for(int i=0;i<9;i++) { stu[j].yuwen[0] = (double) 0; stu[j].math[0] = (double) 0; stu[j].wuli[0] = (double) 0; stu[j].IDE = input.next(); stu[j].name = input.next(); String kemu=input.next(); if(kemu.equals("语文")) { stu[j].yuwen[1] = Double.valueOf(input.next()); stu[j].yuwen[2] = Double.valueOf(input.next()); } if(kemu.equals("数学")) { stu[j].math[1] = Double.valueOf(input.next()); stu[j].math[2] = Double.valueOf(input.next()); } if(kemu.equals("物理")) { stu[j].wuli[1] = Double.valueOf(input.next()); stu[j].wuli[2] = Double.valueOf(input.next()); } k++; if(k == 3){ k=0; j++; } } for(int i=0;i<3;i++){ stu[i].getall(); stu[i].aver(); stu[i].shuchu(); } } public static class student { String IDE; String name; String kemu1; String kemu2; String kemu3; Double []yuwen=new Double[3]; Double[] math =new Double[3]; Double[] wuli=new Double[3]; int allnum=0; String average1; String average2; String average3; public void getall(){ /*this.allnum= (int) (Double.parseDouble(yuwen[1]+math[1]+wuli[1])*0.4)+(int) (Double.parseDouble(yuwen[2]+math[2]+wuli[2])*0.6);*/ /*int a=(int)(Double.parseDouble(this.yuwen[1])+Double.parseDouble(this.math[1])+Double.parseDouble(this.wuli[1])); int b=(int)(Double.parseDouble(this.yuwen[2])+Double.parseDouble(this.math[2])+Double.parseDouble(this.wuli[2]));*/ /*int a=Integer.parseInt(yuwen[1])+Integer.parseInt(math[1])+Integer.parseInt(wuli[1]); int b=Integer.parseInt(yuwen[2])+Integer.parseInt(math[2])+Integer.parseInt(wuli[2]);*/ /*this.allnum= (int) (a*0.4+b*0.6);*/ allnum += (int)((double) (this.yuwen[1])*0.4+(double) (this.yuwen[2])*0.6); allnum += (int)((double) (this.math[1])*0.4+(double) (this.math[2])*0.6); allnum += (int)((double) (this.wuli[1])*0.4+(double) (this.wuli[2])*0.6); } public void aver(){ this.average1 = String.format("%.2f",(Double.parseDouble(String.valueOf(this.yuwen[1]))+Double.parseDouble(String.valueOf(this.math[1]))+Double.parseDouble(String.valueOf(this.wuli[1])))/3D); /* this.average1=(Double.parseDouble(this.yuwen[1])+Double.parseDouble(this.math[1])+Double.parseDouble(this.wuli[1]))/3;*/ /* this.average2= (Double.parseDouble(this.yuwen[2])+Double.parseDouble(this.math[2])+Double.parseDouble(this.wuli[2]))/3;*/ this.average2 =String.format("%.2f",(Double.parseDouble(String.valueOf(this.yuwen[2]))+Double.parseDouble(String.valueOf(this.math[2]))+Double.parseDouble(String.valueOf(this.wuli[2])))/3D); this.average3=String.format("%.2f",this.allnum/3D); } public void shuchu(){ //22201311 张琳 242 76.67 84.00 80.67 System.out.println(this.IDE+" "+this.name+" "+this.allnum+" "+this.average1+" "+this.average2+" "+this.average3); } } }
代码分析：
依旧是创建一个学生类数组，将九个数据都录入进去之后，利用一个函数得到总分，再用总分除以三即可得到相应的平均分
刚开始存入数组数据的时候，由于我成绩数组是double，而输入是string类型，一直无法匹配，提示为（不兼容的类型。实际为 java.lang.String'，需要 'java.lang.Double'），后面加上了Double.valueOf(input.next())，才可以运行
保留两位小数的要求使用"%.2f来满足
7-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; import java.util.ArrayList; import java.util.List; public class Main{ public static void main(String[] args){ Menu menu = new Menu(); menu.dishs =new Dish[4]; menu.dishs[0] = new Dish("西红柿炒蛋",15); menu.dishs[1] = new Dish("清炒土豆丝",12); menu.dishs[2] = new Dish("麻婆豆腐",12); menu.dishs[3] = new Dish("油淋生菜",9); Scanner input = new Scanner(System.in); String name; name = input.next(); Order order=new Order(); int sum = 0; while (name.equals("end")==false) { int num; num=input.nextInt(); if(menu.searthDish(name)!=null){ order.addARecord(menu.searthDish(name),num); sum+=menu.searthDish(name).getPrice(num); } else if (name.equals("end")==false) System.out.print(name+" does not exist\n"); name=input.next(); } System.out.println(sum); } static class Order { List<Record> records = new ArrayList<>(); void addARecord(Dish dish, int portion) { Record record = new Record(dish, portion); records.add(record); } } public static class Record { Dish d;//菜品 int portion;//份额（1/2/3代表小/中/大份） public Record(Dish dish, int portion) { this.d=dish; this.portion=portion; } int getPrice()//计价，计算本条记录的价格 { return d.getPrice(portion); } } public static class Dish { String name;//菜品名称 int unit_price; //单价 Dish(){} Dish(String name,int price) { this.name = name; this.unit_price = price; } public int getPrice(int portion) { float bl[] = {1,1.5f,2}; return Math.round(unit_price*bl[portion-1]); } } public static class Menu { Dish[] dishs ;//菜品数组，保存所有菜品信息 Dish searthDish(String dishName){ for(int i =0;i< dishs.length;i++){ if(dishName.equals(dishs[i].name)) return dishs[i]; } return null; } } }
代码分析
先在dish中存入菜品，再写一个不同容量菜钱的计算函数
刚开始因为不知道输入有几行，不知道动态数组怎么建立，后面在网上查找后使用了ArrayList<>()来创建动态数组，这样不管输入几行都能够存进数组中并且调用
如何再输出菜品名错误的条件下，输出另外两件菜的总价这是第二个问题，因为刚开始我的输出函数是写在结尾的，如果菜品名错误了程序就会直接截止。后面我将菜品名错误的输出代码写在了判断条件的下一句，总价钱依然写在结尾，这样就能够解决
这个问题了
本题目用的类有三四个，很容易绕晕，但是抽丝剥茧写出来之后还是挺好理解的
第三次作业：7-1 jmu-java-日期类的基本使用
- 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
- 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"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; import java.time.LocalDate; import java.time.temporal.ChronoField; import java.time.Duration; import java.time.Period; import java.time.LocalDateTime; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String line1 = input.nextLine();//输入日期1 2021-02-28 String line2 = input.nextLine();//输入日期2 2021-02-28 String[] arr = line1.split("-"); // 以/为分隔符，提取年月日 int year = Integer.parseInt(arr[0]); //转换为int型 int mouth = Integer.parseInt(arr[1]); int day = Integer.parseInt(arr[2]); if(!geshi(line1,year,mouth,day)){ System.out.println(line1+"无效!"); } if(geshi(line1,year,mouth,day)) { if (runnian(year) == 1) { System.out.println(line1 + "是闰年."); } bennian(line1, year, mouth, day); } String[] arr1 = line2.split(" "); String[] b = arr1[0].split("-"); int year1 = Integer.parseInt(b[0]); //转换为int型 int mouth1 = Integer.parseInt(b[1]); int day1 = Integer.parseInt(b[2]); String[] c = arr1[1].split("-"); int year2 = Integer.parseInt(c[0]); //转换为int型 int mouth2 = Integer.parseInt(c[1]); int day2 = Integer.parseInt(c[2]); if(geshi(arr1[0],year1,mouth1,day1)&&geshi(arr1[1],year2,mouth2,day2)){ int result = arr1[0].compareTo(arr1[1]); if(result>=0) System.out.printf(arr1[1]+"早于"+arr1[0]+",不合法!"); if(result<0){ LocalDateTime localDateTimeStart=LocalDateTime.of(year1,mouth1,day1,0,0,0); LocalDateTime localDateTimeEnd=LocalDateTime.of(year2,mouth2,day2,0,0,0); Duration duration =Duration.between(localDateTimeStart,localDateTimeEnd); //System.out.println("相差绝对天数："+duration.toDays()); LocalDate localDateStart=LocalDate.of(year1,mouth1,day1); LocalDate localDateEnd=LocalDate.of(year2,mouth2,day2); Period period =Period.between(localDateStart,localDateEnd); //System.out.println("相差绝对月数："+period.toTotalMonths()); if(mouth2<mouth1)//2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1. System.out.printf(arr1[1]+"与"+arr1[0]+"之间相差"+duration.toDays()+"天,所在月份相差"+(mouth2-mouth1)+",所在年份相差"+(year2-year1)+"."); if (mouth2>mouth1) System.out.printf(arr1[1]+"与"+arr1[0]+"之间相差"+duration.toDays()+"天,所在月份相差"+(mouth2-mouth1)+",所在年份相差"+(year2-year1)+"."); } } else System.out.printf(arr1[0]+"或"+arr1[1]+"中有不合法的日期."); } public static void bennian(String line5,int year5,int mouth5,int day5){ LocalDate line = LocalDate.of(year5, mouth5, day5); int year = line.get(ChronoField.YEAR); System.out.printf(line5+"是当年第" + line.getDayOfYear() + "天,"); // 月份 int month = line.get(ChronoField.MONTH_OF_YEAR); System.out.printf("当月第" + line.getDayOfMonth() + "天,"); // 周 /*int week = line.get(ChronoField.ALIGNED_WEEK_OF_MONTH); System.out.println("该日期是当月的第 " + line.getDayOfWeek().getValue() + " 天");*/ // 星期几 int dayOfWeek = line.get(ChronoField.DAY_OF_WEEK); System.out.println("当周第" + dayOfWeek + "天."); } public static boolean geshi(String line,int year,int mouth,int day){ if(line.matches("^\\d{4}-+\\d{2}-+\\d{2}$")){ if(year<3000&&year>1850){ if(mouth<13&&mouth>0){ if(mouth==2){ if(runnian(year)==1){ if(day<30&&day>0) return true; else return false; } else{ if(day<29&&day>0) return true; else return false; } } else if(mouth==1||mouth==3||mouth==5||mouth==7||mouth==8||mouth==10||mouth==12){ if(day<32&&day>0) return true; else return false; } else { if (day < 31 && day > 0) return true; else return false; } } else return false; } else return false; } return false; } public static int runnian(int year){ if(year%4==0&&year%100!=0||year%400==0){ return 1; }else{ return 0; } } }
代码分析：
刚开始并不知道java有时间类相关和分隔符的函数，走了很多弯路单独去写将数组断开和判断两个时间之间的差值，但是自己写还是有点力不从心。后面去网上搜索后发现java本身存在相应计算的类，直接加声明再引用即可，自此代码大致有了方向
使用String[] arr = line1.split("-")将第一行的字符串分开，分别化成int型存入三个变量中去，先判断数据合法性，再写一个闰年判断函数
再写一个函数判断这个日期再本年第几日和本月第几日，使用
LocalDate line = LocalDate.of(year5, mouth5, day5);
line.getDayOfYear()
line.getDayOfMonth()
但是不知道为什么还有有个地方无法得到满分，明明测试的时候输入给的是输出结果和题目的值是一样的
7-2 课程成绩统计程序-1
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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.util.*; public class Main { public static void main(String[] args) { List<CourseSelect> courseSelects = new ArrayList<>(); List<Course> courses = new ArrayList<>(); List<Student> students = new ArrayList<>(); Scanner in = new Scanner(System.in); String input = in.nextLine(); while (!input.equals("end")) { String[] arr = input.split(" "); if (isCourseInput(arr)) {//输入的是课程信息 if (arr[1].equals("必修") && arr[2].equals("考察")) { //课程性质和课程的考核方式不匹配 System.out.println(arr[0] + " : course type & access mode mismatch"); } else { Course course = createCourse(arr); courses.add(course); } } else if (isCourseSelectInput(arr)) {//输入的是选课 int m = findCourse(courses, arr[2]); if (courses.isEmpty()) { System.out.println(arr[2] + " does not exist"); } else { //有这门课 if (m != -1) { int i = m; //输入的成绩数量和课程的考核方式不匹配 if ((courses.get(i).courseMethod.equals("考试") && arr.length != 5) || (courses.get(i).courseMethod.equals("考察") && arr.length != 4)) { System.out.println(arr[0] + " " + arr[1] + " : access mode mismatch"); } else { CourseSelect courseSelect = createCourseSelect(arr); courseSelects.add(courseSelect); } } else {//课程信息没有这门课 System.out.println(arr[2] + " does not exist"); } } // 学生信息防止重复 //录入学生信息 int isSameStudent = isSameStudent(students, arr[0]); if (isSameStudent == 0) { Student student = createStudent(arr); students.add(student); } } else { System.out.println("wrong format"); } input = in.nextLine(); } Student student = new Student(); Course course = new Course(); student.showStudentScore(students, courseSelects); course.showCourseScore(courses, courseSelects); } public static boolean isCourseInput(String[] arr) { if (arr.length < 3 || arr.length > 4) { return false; } if (!arr[0].matches("[\\u4e00-\\u9fa5a-zA-Z]{1,10}")) { return false; } if (!arr[1].equals("必修") && !arr[1].equals("选修")) { return false; } if (!arr[2].equals("考试") && !arr[2].equals("考察")) { return false; } return true; } public static boolean isCourseSelectInput(String[] arr) { if (arr.length < 3 || arr.length > 5) { return false; } if (!arr[0].matches("\\d{8}")) { return false; } if (!arr[1].matches("[\\u4e00-\\u9fa5a-zA-Z]{1,10}")) { return false; } if (!arr[2].matches("[\\u4e00-\\u9fa5a-zA-Z]{1,10}")) { return false; } if (!arr[3].matches("([0-9]|[1-9][0-9]|100)")) { return false; } if (arr.length == 5 && !arr[4].matches("([0-9]|[1-9][0-9]|100)")) { return false; } return true; } public static int findCourse(List<Course> courses, String courseName) { int m = -1; for (int i = 0; i < courses.size(); i++) { if (courses.get(i).courseName.equals(courseName)) { m = i; break; } } return m; } public static int isSameStudent(List<Student> students, String studentID) { int isSameStudent = 0; for (Student s : students) { if (s.studentID.equals(studentID)) { isSameStudent = 1; break; } } return isSameStudent; } public static Course createCourse(String[] arr) { Course course = new Course(); course.courseName = arr[0]; course.courseType = arr[1]; course.courseMethod = arr[2]; return course; } public static CourseSelect createCourseSelect(String[] arr) { CourseSelect courseSelect = new CourseSelect(); Course course = new Course(); Student student = new Student(); //课程 course.courseName = arr[2]; courseSelect.course = course; //学生 student.studentID = arr[0]; student.studentName = arr[1]; courseSelect.student = student; //考试 if (arr.length == 5) { ExamCourse exam = new ExamCourse(); exam.dailyScore = Integer.parseInt(arr[3]); exam.finalScore = Integer.parseInt(arr[4]); courseSelect.score = exam; } //考察 else if (arr.length == 4) { InspectCourse inspect = new InspectCourse(); inspect.finalScore = Integer.parseInt(arr[3]); courseSelect.score = inspect; } return courseSelect; } public static Student createStudent(String[] arr) { Student student = new Student(); student.studentID = arr[0]; student.studentName = arr[1]; return student; } } class Course { String courseName; String courseType; String courseMethod; public void showCourseScore(List<Course> courses, List<CourseSelect> courseSelects) { for (Course c : courses) { System.out.println(c.courseName + " has no grades yet"); } } } class CourseSelect { Course course; Student student; Score score; public CourseSelect() { } } class ExamCourse extends Score { int dailyScore; int finalScore; } class InspectCourse extends Score { int finalScore; public InspectCourse() { } } abstract class Score { public Score() { } } class Student { String studentID; String studentName; public void showStudentScore(List<Student> students, List<CourseSelect> courseSelects) { for (Student s : students) { System.out.println(s.studentID + " " + s.studentName + " did not take any exams"); } } }
代码分析：
这题实在是写不了一点，题目都把我绕晕了，光是理清题目都花了不少时间，理清题目后本来是想一口气将功能全部实现，但是交错互动性太强了，写了几天别说功能全部实现，跑都跑不起来，眼看快截止了只能删掉源代码重新开始另写。
后面我是一个一个功能开始写，真正的面向对象，一个要求一个要求的来，但是以我目前的水平还是只能实现寥寥几个功能，虽然有很多个类但是又有几个类只有几个元素一个行为，甚至有的一个行为都没有只有几个元素。
使用的格式也参差不齐，有的时候出现了String类型赋值给int对象的情况经常需要手动给他改变格式
对于输入的字符串，首先需要检查其格式是否正确
然后将字符串分隔开，检查其长度
根据不同的长度再写不同的函数去判断并输出结果
改进建议：
大致框架已经构建好，各分类也是由于目前的知识储备不足无法完善，日后可以再慢慢完善打磨
总结：
1.前两次的作业较为简单，能够做出来，但是第三次的作业着实是想了好久还没头绪
2.以我目前的能力写短篇代码还行，一但代码达到两百行以上，思维逻辑关联性再强一点的话，我就无法写出来，还是知识储备的不足
3.代码结构不严谨，取名字也比较随意不符合规范，数据经常需要在各种型式中进行转换，浪费了资源
4.题目的深层逻辑性有时候没搞清导致拿不了满分
5.踩坑分析和主要困难均在各题中的代码分析中给出
浙公网安备 33010602011771号