前言
此Blog是对Java的PTA作业的总结，旨在分析和总结所做过的Java题目，以加深对Java的理解和加强对Java的运用。
前三次PTA中涉及到了类和数组的基本运用，字符串的操作，数据的封装，日期类的方法的基本运用等知识点。
第一次作业题量适中，难度也适中；第二次作业题量偏多，难度偏大；第三次作业虽然题量不多，但是难度大大提升。
PTA第一次作业
（这是我第一次接触Java，Java作为一门面向对象的语言，在编程逻辑上和C语言有所不同，但逻辑思路上和C语言相似，主要是学习Java中的各类方法和对对象操作的思路）
第一次PTA作业主要是让我们认识Java这门语言，在Java中，所有操作都需要放在类里面进行。
我选择其中一道“二进制数值提取”题目为例，分享我学习Java的过程。
该题的输入格式要求：
一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1
输出格式要求：
将输入的序列去掉非0、1字符以及结尾符的数据内容。
注：结束符-1之后的0\1字符忽略不计。
例如：00011。
经过分析，该题主要是对输入的数据进行筛选，选择需要的数据输出。
通过查询资料，我学习到了Java中对字符串操作的方法，因此顺利的完成了这道题目。
源代码如下：
1 import java.util.Scanner;
2 import java.lang.StringBuffer;
3
4 public class Main{
5 public static void main(String[] args){
6 Scanner input=new Scanner(System.in);
7 String chars=input.nextLine();
8 int location=chars.indexOf("-1");
9 if (location==-1)
10 System.out.println("Wrong Format");
11 else {
12 String cut=chars.substring(0,location);
13 for (int i=0;i<cut.length();i++)
14 {
15 if (cut.charAt(i)=='0'||cut.charAt(i)=='1')
16 System.out.print(cut.charAt(i));
17 }
18 }
19 }
20 }
PTA第二次作业
第二次PTA作业就开始涉及面向对象的操作了，我们需要自己创建类，并且在类里写上该类的一些操作方法。对于复杂的题目，我们还需要创建类图以便于更直观的分析题目。
在此次作业中，我将以7-1、7-2和7-7为例，分析Java的学习思路。
7-1和7-2都是强化我们对Java中类的理解和运用，以及类与类之间如何关联起来。因此我将两道题目合并起来分析。
首先给出题目：
（7-1）创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
（7-2）创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
分析题目可知，这两题都需要创建学生类对象，然后对学生的成绩数据进行计算，最后输出。
由于Java的编程逻辑是将方法和对象结合起来操作，因此学生成绩的计算方法应该和学生类绑定，而第二题中则需要新增总成绩类，思路大致相同。
（7-1）源代码如下：
1 import java.util.Scanner;
2
3 public class Main{
4 public static void main(String[] args){
5 Scanner input = new Scanner(System.in);
6 Student[] stus=new Student[5];
7 for (int i=0;i<5;i++)
8 stus[i] = new Student();
9 for (int i=0;i<5;i++)
10 {
11 stus[i].stu_id=input.next();
12 stus[i].name=input.next();
13 stus[i].chinese=input.nextInt();
14 stus[i].math=input.nextInt();
15 stus[i].physical=input.nextInt();
16 }
17 for (int i=0;i<5;i++)
18 System.out.printf("%s %s %d %.2f\n",stus[i].stu_id,stus[i].name,stus[i].all_score(),stus[i].average());
19 }
20 public static class Student{
21 private String stu_id;
22 private String name;
23 private int chinese;
24 private int math;
25 private int physical;
26 public int all_score(){
27 return chinese+math+physical;
28 }
29 public double average(){
30 return (chinese+math+physical)/3.0;
31 }
32 }
33 }
（7-2）源代码如下：
1 import java.util.Scanner;
2
3 public class Main{
4 public static void main(String[] args){
5 Scanner input = new Scanner(System.in);
6 Student[] stus=new Student[3];
7 Score[][] stu_score=new Score[3][3];
8 for (int i=0;i<3;i++){
9 for (int j=0;j<3;j++){
10 stus[i] = new Student();
11 stu_score[i][j] = new Score();
12 stus[i].studentID=input.next();
13 stus[i].studentname=input.next();
14 String a=input.next();
15 stu_score[i][j].peacetime_grades=input.nextInt();
16 stu_score[i][j].final_grades=input.nextInt();
17 }
18 stus[i].chinese=stu_score[i][0].score();
19 stus[i].math=stu_score[i][1].score();
20 stus[i].physical=stu_score[i][2].score();
21 }
22 for (int i=0;i<3;i++)
23 {
24 System.out.printf("%s %s %d %.2f %.2f %.2f\n",stus[i].studentID,stus[i].studentname,stus[i].all_score(),stus[i].average(stu_score[i][0].peacetime_grades,stu_score[i][1].peacetime_grades,stu_score[i][2].peacetime_grades),stus[i].average(stu_score[i][0].final_grades,stu_score[i][1].final_grades,stu_score[i][2].final_grades),stus[i].average(stus[i].chinese,stus[i].math,stus[i].physical));
25 }
26 }
27 public static class Score{
28 int peacetime_grades;
29 int final_grades;
30 public int score(){
31 return (int)(peacetime_grades*0.4+final_grades*0.6);
32 }
33 }
34 public static class Student{
35 private String studentID;
36 private String studentname;
37 private int chinese;
38 private int math;
39 private int physical;
40
41 public int all_score(){
42 return chinese+math+physical;
43 }
44 public double average(int x,int y,int z){
45 return (x+y+z)/3.0;
46 }
47 }
48 }
由于这两题比较简单，因此不创建类图和复杂度分析。
7-7这一题，相较前面的题目难度大了很多，需要我们做出一个菜单计价系统。
题目要求如下：
某饭店提供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)
//添加一条菜品信息到订单中。
}
该题给出了类的部分定义，需要我们通过这些类的定义完善整个系统。
分析该题目可知，各类之间存在这一定的联系，找到这些联系之后，便可以将各类关联起来，然后进行价格的计算。
Java是一门面向对象的编程，因此从对象操作开始入手。
创建类图，对每个类进行分析之后便可以得到各类的操作方法，随后将各类联系起来便可以完善该系统。
类图如下：
Dish类：表示一个菜品，包含菜品名称name和单价unit_price。通过getPrice方法根据份数计算价格。Menu类：表示菜单，包含菜品数组dishs和searchDish方法用于查找菜品。Record类：表示一条点餐记录，包含菜品d和份数portion。通过getPrice方法获取该记录的价格。Order类：表示订单，包含点餐记录数组records、菜单对象menu和相应的操作方法。
源代码如下：
1 import java.util.Scanner;
2
3 public class Main {
4 public static void main(String[] args) {
5 Scanner input = new Scanner(System.in);
6 Order ord = new Order();
7 int i = 0;
8 while (true) {
9 String dishName = input.next();
10 if (dishName.equalsIgnoreCase("end"))
11 break;
12 int portion = input.nextInt();
13 if (ord.addARecord(dishName, portion) == null)
14 System.out.println(dishName + " does not exist");
15 else ord.records[i++] = ord.addARecord(dishName, portion);
16 }
17
18 System.out.println(ord.getTotalPrice());
19 }
20
21 public static class Dish {
22 String name;
23 int unit_price;
24
25 public Dish(String name, int unit_price) {
26 this.name = name;
27 this.unit_price = unit_price;
28 }
29
30 int getPrice(int portion) {
31 double price = 0;
32 switch (portion) {
33 case 1:
34 price = unit_price;
35 break;
36 case 2:
37 price = 1.5 * unit_price;
38 break;
39 case 3:
40 price = 2 * unit_price;
41 break;
42 }
43 return (int) Math.round(price);
44 }
45 }
46
47 public static class Menu {
48 Dish[] dishs;
49
50 public Menu() {
51 dishs = new Dish[4];
52 dishs[0] = new Dish("西红柿炒蛋", 15);
53 dishs[1] = new Dish("清炒土豆丝", 12);
54 dishs[2] = new Dish("麻婆豆腐", 12);
55 dishs[3] = new Dish("油淋生菜", 9);
56 }
57
58 Dish searchDish(String dishName) {
59 for (int i=0;i<4;i++) {
60 if (dishs[i].name.equals(dishName)) {
61 return dishs[i];
62 }
63 }
64 return null;
65 }
66 }
67
68 public static class Record {
69 Dish d;
70 int portion;
71
72 int getPrice() {
73 return d.getPrice(portion);
74 }
75 }
76
77 public static class Order {
78 Record[] records = new Record[10];
79 Menu menu;
80
81 public Order() {
82 menu = new Menu();
83 }
84
85 int getTotalPrice() {
86 int total = 0;
87 int i=0;
88 while ( records[i]!=null) {
89 total += records[i++].getPrice();
90 }
91 return total;
92 }
93
94 Record addARecord(String dishName, int portion) {
95 Dish foundDish = menu.searchDish(dishName);
96 if (foundDish == null) {
97 return null;
98 } else {
99 Record a = new Record();
100 a.d = foundDish;
101 a.portion = portion;
102 return a;
103
104
105 }
106 }
107 }
108 }
此代码的复杂度分析如下：
代码流程分析如下：
- 创建
Scanner对象input，用于接收用户输入。 - 创建
Order对象ord。 - 使用循环读取用户输入的菜品名称和份数，直到输入
"end"为止。 - 根据菜品名称和份数调用
addARecord方法创建一条点餐记录，如果菜品不存在则返回null。 - 如果点餐记录不为空，将其存储在
records数组中。 - 输出订单的总价格，即调用
getTotalPrice方法。
第二次PTA题目总结：通过此次作业，我加深了对类的理解，掌握了对类的运用，各类的方法操作，和日期类的基本运用。此次作业将类与类之间关联起来操作，使我对Java的编程运用更加灵活。
PTA第三次作业
此次作业中，难度最大的便是7-2：课程成绩统计程序。
因此，在此次作业中，只对该题进行分析。
7-2题目要求如下：
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃
该题复杂度很高，相较于上一次作业的“菜单计价系统”，该题对类之间的联系更加紧密，逻辑要求更高，需要将各类串联起来才能完成该题。
首先我们需要创建四个对象，分别是班级类、学生类、课程类和成绩类。在这些类中，我们还要写出成绩计算的方法操作。
根据题目分析可知，学生类需要和班级类关联，成绩又需要和班级关联；成绩类和课程类都要和学生类联系在一起，成绩类又要和课程类关联在一起。
基于这样的逻辑，我们需要在各类中创建其他类的数组以便于关联，在主程序中有逻辑的调用这些类，以便于数据的存入和读取，还需要对数据的格式、是否超出范围进行判定。
因此，类图创建如下：
course_abstract是一个抽象类，用于定义课程的基本属性，包括课程名称、考核方式、平时成绩和考试成绩。它还有一个抽象方法getscores()，用于计算课程的总分，具体的总分计算由子类实现。
course类继承自course_abstract，表示具体的课程对象，包含了课程名称、属性、考核方式、总分、平时成绩总分和考试成绩总分等属性。它重写了父类的getscores()方法，根据考核方式计算总分。
student类表示学生对象，包含学号、姓名、选修课程列表等属性。每个学生对象可以选择多门课程，并将其存储在一个选修课程列表中。
s_class类表示班级对象，包含班号和成绩等属性。每个班级对象包含多个学生对象。
源代码如下：
1 import java.util.Scanner;
2 import java.util.regex.Pattern;
3 import java.util.regex.Matcher;
4
5 public class Main{
6 private static String s_id = "^\\d{8}$";//学号
7 public static void main(String[] args) {
8 Scanner input = new Scanner(System.in);
9 String[] put;
10 course[] Course=new course[10];
11 student[] Student=new student[20];
12 s_class[] Class=new s_class[10];
13 String flag="";
14 String flag1="";
15 String flag2="";
16 int i=0,j=0,k=0,l=0,b=0;
17 boolean pue = true;
18 while (true) {
19 String obtain = input.nextLine();
20 if (obtain.equalsIgnoreCase("end"))
21 break;
22 put = obtain.split(" ");
23 if (put.length<=3){
24 if (flag2.equals(put[0]))
25 ;
26 else {
27 flag2 = put[0];
28 Course[i]=new course(put[0],put[1]);
29 if (put[1].equals("必修"))
30 Course[i].setmode("考试");
31 else Course[i].setmode("考察");
32 if (put[1].equals("必修")&&put[2].equals("考察")){
33 System.out.println(put[0]+" : course type & access mode mismatch");
34 Course[i]=null;
35 }
36 i++;}
37 }
38 else {
39 i=0;
40 if (!flag1.equals(put[0].substring(0,6)))
41 {
42 Class[l] = new s_class(put[0].substring(0,6));
43 flag1 = Class[l++].classid;
44 }
45 if (!flag.equals(put[0])) {
46 Student[j++] = new student(put[0], put[1]);
47 flag=put[0];
48 k=0;
49 }
50 Student[j-1].course[k]=new course_abstract(put[2]);
51 for (course a:Course){
52 if (a!=null)
53 if (Student[j-1].course[k].name.equals(a.name)) {
54 Student[j-1].course[k].setmode(a.mode);
55 b=i;
56 }
57 i++;
58 }
59 if (Student[j-1].course[k].mode==null)
60 {
61 System.out.println(Student[j-1].id+" "+Student[j-1].name+" : "+put[2]+" does not exist");
62 }
63 else if (Student[j-1].course[k].mode.equals("考试")&&put.length==4)
64 System.out.println(Student[j-1].id+" "+Student[j-1].name+" : access mode mismatch");
65 else if(put.length==4){
66 if (Integer.parseInt(put[3])>=0&&Integer.parseInt(put[3])<=100){
67 Student[j-1].course[k].final1=Integer.parseInt(put[3]);
68 Course[b].setfinal(Integer.parseInt(put[3]));
69 Course[b].setall();}
70 else System.out.println("wrong format");
71 }
72 else {
73 if ((Integer.parseInt(put[3])>=0&&Integer.parseInt(put[3])<=100)&&(Integer.parseInt(put[4])>=0&&Integer.parseInt(put[4])<=100)){
74 Student[j-1].course[k].usual=Integer.parseInt(put[3]);
75 Student[j-1].course[k].final1=Integer.parseInt(put[4]);
76 Course[b].setusual(Integer.parseInt(put[3]));
77 Course[b].setfinal(Integer.parseInt(put[4]));
78 Course[b].setall();}
79 else System.out.println("wrong format");
80 }
81 Class[l-1].setall(Student[j-1].course[k++].getscores());
82 }
83 }
84 Pattern q = Pattern.compile(s_id);
85 Matcher n;
86 Student = student_sort(Student);
87 Class = class_sort(Class);
88 Course = course_sort(Course);
89 for (student a:Student){
90 if (a!=null) {
91 n = q.matcher(a.id);
92 if (a.name.length()<=10 && n.matches())
93 if (a.all_scores() <= 0)
94 System.out.println(a.id + " " + a.name + " did not take any exams");
95 else System.out.println(a.id + " " + a.name + " " + a.all_scores());
96 else System.out.println("wrong format");
97 }
98 }
99 for (course a: Course){
100 if (a!=null) {
101 if (a.name.length()<=10)
102 if (a.get_allaverage() <= 0)
103 System.out.println(a.name + " has no grades yet");
104 else if (a.get_uaverage() != 0) {
105 System.out.println(a.name + " " + a.get_uaverage() + " " + a.get_faverage() + " " + a.get_allaverage());
106 } else System.out.println(a.name + " " + a.get_faverage() + " " + a.get_allaverage());
107 else System.out.println("wrong format");
108 }
109 }
110 for (s_class a:Class){
111 if (a!=null) {
112 if (a.all_average() <= 0)
113 System.out.println(a.classid + " has no grades yet");
114 else System.out.println(a.classid + " " + a.all_average());
115 }
116 }
117 }
118 public static student[] student_sort(student[] a){
119 for (int i=0;i<a.length-1;i++)
120 for (int j=0;j<a.length-i-1;j++)
121 if (a[j+1]!=null)
122 if (Integer.parseInt(a[j].id)>Integer.parseInt(a[j+1].id)) {
123 student temp = a[j];
124 a[j] = a[j + 1];
125 a[j + 1] = temp;
126 }
127 return a;
128 }
129 public static s_class[] class_sort(s_class[] a){
130 for (int i=0;i<a.length-1;i++)
131 for (int j=0;j<a.length-i-1;j++)
132 if (a[j+1]!=null)
133 if (Integer.parseInt(a[j].classid)>Integer.parseInt(a[j+1].classid)) {
134 s_class temp = a[j];
135 a[j] = a[j + 1];
136 a[j + 1] = temp;
137 }
138 return a;
139 }
140 public static course[] course_sort(course[] a){
141 for (int i=0;i<a.length-1;i++)
142 for (int j=0;j<a.length-i-1;j++)
143 if (a[j+1]!=null)
144 if (a[j].name.charAt(0)>a[j+1].name.charAt(0)) {
145 course temp = a[j];
146 a[j] = a[j + 1];
147 a[j + 1] = temp;
148 }
149 return a;
150 }
151 }
152 class s_class{
153 String classid;
154 int all=0;
155 int count=0;
156 public s_class(String classid){
157 this.classid=classid;
158 }
159 public void setall(int scores){
160 this.all+=scores;
161 count++;
162 }
163 public int all_average(){
164 if (count==0)
165 return all;
166 return all/count;
167 }
168 }
169
170 class student{
171 String id;
172 String name;
173 course_abstract[] course;
174 public student(String id,String name){
175 this.id= id;
176 this.name= name;
177 course = new course_abstract[10];
178 }
179 public int all_scores(){
180 int all=0;
181 int count=0;
182 for (course_abstract Course:course){
183 if (Course!=null) {
184 all += Course.getscores();
185 count++;
186 }
187 }
188 if (count==0)
189 return all;
190 return all/count;
191 }
192 }
193 class course{
194 String name;
195 String properties;
196 String mode;
197 course_abstract couese;
198 int all;
199 int allusual=0;
200 int allfinal=0;
201 int count;
202 public course(String name,String properties){
203 this.name=name;
204 this.properties=properties;
205 this.count=0;
206 this.all=0;
207 couese = new course_abstract(name);
208 couese.setusual(0);
209 couese.setfanal1(0);
210 }
211 public void setmode(String mode){
212 couese.setmode(mode);
213 this.mode=mode;
214 }
215 public void setusual(int usual){
216 couese.usual=usual;
217 this.allusual+=usual;
218 }
219 public void setfinal(int final1){
220 couese.final1=final1;
221 this.allfinal+=final1;
222 }
223 public void setall(){
224 this.all+=couese.getscores();
225 this.count++;
226 }
227 public int get_uaverage(){
228 return allusual/count;
229 }
230 public int get_faverage(){
231 return allfinal/count;
232 }
233 public int get_allaverage(){
234 if (count==0)
235 return all;
236 return all/count;
237 }
238 }
239 class course_abstract{
240 String name;
241 String mode;
242 int usual=-1;
243 int final1=-1;
244 public course_abstract(String name){
245 this.name = name;
246 }
247 public void setmode(String mode){
248 this.mode= mode;
249 }
250 public void setusual(int usual){
251 this.usual= usual;
252 }
253 public void setfanal1(int final1){
254 this.final1= final1;
255 }
256 public int getscores(){
257 if (mode!=null){
258 if (mode.equals("考察"))
259 return final1;
260 if (mode.equals("考试")) {
261 if (usual==-1||final1==-1)
262 return 0;
263 return (int) (usual * 0.3 + final1 * 0.7);
264 }
265 }
266 return (int)(usual*0.3+final1*0.7);
267 }
268 }
此代码的复杂度分析如下：
代码流程分析如下：
- 定义一些变量和对象，如存储课程、学生和班级信息的数组，以及用于输入的 Scanner 对象等。
- 进入 while 循环，读取输入的每一行，并根据空格分割字符串，将输入分为三种类型：课程信息、班级信息、学生成绩信息。
- 如果输入为课程信息，将课程存入课程数组中，判断课程属性是否正确，然后将课程加入课程数组。
- 如果输入为班级信息，将班号存入班级数组中，检查是否需要新建班级，如果是则创建新的班级对象。检查学生是否已存在，如果不存在，则创建学生对象并添加到学生数组中。将学生的选课信息存入相应的课程对象中，并根据考核方式进行处理。
- 如果输入为学生成绩信息，查询该学生是否选择了该门课程，如果是，则将成绩信息存入课程对象中，并更新课程的总分、平时成绩和考试成绩等属性。
- 对学生数组按学号进行排序。
- 对班级数组按班号进行排序。
- 对课程数组按名称的首字母进行排序。
- 遍历班级数组，输出班级信息及班级内每个学生的成绩情况。
由于该题难度很高，故我所写的代码中依然存在一些bug。我还需要对程序不断的进行断点调试，以消除bug。
虽然没能将该题完全做出来，但我还是学习到了很多。在Java中，创建一个庞大的系统首先需要创建各类对象，理清各类对象之间的联系和逻辑以及操作，随后将各类对象串联起来。
踩坑心得
类的操作中，最大的坑就是类数组的创建。
在“菜单计价系统”这一题中，我需要在订单类中创建一个记录菜单类数组，我首先想到的便是直接在主程序中调用这个类的属性类，声明数组并给它分配空间。
例如该句：
Order ord = new Order(); Record[] ord.records = new Record[10];
但是在编译软件中，该句报出以下错误：
Navigate to previous declared variable 'ord'
Create local variable 'records'
Create field 'records' in 'Main'
Create parameter 'records'
Rename reference
我查询资料后得知，属性类的数组的创建，不能在主程序中分配空间，应该在属性类所在的类中分配空间，因为Java是对类进行操作。
因此，上述操作应该放在Order类里，修改如下：
public static class Order {
Record[] records = new Record[10];
……
}
也可修改为无参构造：
public Order() {
menu = new Menu();
Record[] records = new Record[10];
}
还可以修改为有参构造：
public Order(int n) {
menu = new Menu();
Record[] records = new Record[n];
}
属性类数组的创建就如上述操作。
我个人认为这是我学习Java以来遇到的最大的坑，为此我查阅了不少资料，希望读者能够在我的经验总结之下避免再踩这个坑。
总结
经过了三次题目的学习，我已经熟练掌握了Java编程，熟悉了各类的操作方法和类之间的关联，如日期类的基本运用，字符串的基本操作和属性类数组的创建等。
我认为我还需要加强对类的联系运用，并且对于各类之间的逻辑分析还需要深入研究，掌握类图的运用和加强对代码的简化。
标签：总结,题目,String,int,课程,new,Java,成绩,public From： https://www.cnblogs.com/cgh7302/p/17747400.html