一、前言
第六次PTA作业：难度较大，只有一道题，需要综合运用Java的各种技巧
第七次PTA作业：除课程设计外，难度适中，需要综合运用Java的各种技巧
第八次PTA作业：除课程设计外，难度适中，需要综合运用Java的各种技巧
二、设计与分析
第六次PTA作业：
1、设计分析：
题目描述了一个高校课程成绩管理系统。要求输入课程信息和学生的成绩信息，并根据给定的规则计算学生的总成绩平均分、单门课程成绩平均分和班级所有课程总成绩平均分。此外，还要求处理一些异常情况，如课程名称不存在、成绩数量和考核方式不匹配等。
为了实现这个题目，可以先定义一些数据结构来存储输入的信息。可以定义一个课程类，包含课程名称、课程性质和考核方式等属性。定义一个学生类，包含学号、姓名和成绩等属性。
解析输入的信息并将其存储到相应的数据结构中。使用字符串分割函数来分割输入的字符串，并根据输入格式将其转换为相应的数据类型。
根据给定的规则计算学生的总成绩平均分、单门课程成绩平均分和班级所有课程总成绩平均分。使用循环遍历学生列表和课程列表，并根据给定的公式计算相应的平均分。
按照题目要求输出结果。我们可以使用字符串格式化函数来格式化输出结果，并按照题目要求排序输出。
还需要注意处理异常情况，如课程名称不存在、成绩数量和考核方式不匹配等。可以使用条件语句来判断是否出现异常情况，并按照题目要求输出相应的错误信息。
1 import java.text.Collator;
2 import java.util.*;
3
4
5 public class Main {
6 public static void main(String[] args) {
7 Scanner s = new Scanner(System.in);
8 ParseInput handle = new ParseInput();
9 String s_record;
10 while (!(s_record = s.nextLine()).equals("end")) {
11 handle.parseInput(s_record);
12 }
13 handle.MySort();
14 handle.studentScore();
15 handle.CourseScore();
16 handle.ClassScore();
17 }
18 }
19 class ParseInput{
20 private ArrayList<SelectCourse> selectCourses = new ArrayList<>();
21 private ArrayList<Course> courses = new ArrayList<>();
22 private ArrayList<Student> students = new ArrayList<>();
23 private ArrayList<String> Class = new ArrayList<>();
24 public void parseInput(String input) {
25 String[] inputs = input.split(" ");
26 int inputType = InputMatching.matchingInput(input);
27 if (inputType == 1) {
28 if (checkCourse(inputs[0]) == null) {
29 if (inputs[1].equals("必修") && (!inputs[2].equals("考试"))) {
30 System.out.println(inputs[0] + " : course type & access mode mismatch");
31 } else {
32 courses.add(new Course(inputs[0], inputs[1], inputs[2]));
33 }
34 }
35 } else if (inputType == 2) {
36 Student newStudent = new Student(inputs[0], inputs[1]);
37 if (!checkStudent(newStudent.getNum())) students.add(newStudent);
38 if (!checkClass(inputs[0].substring(0, 6))) Class.add(inputs[0].substring(0, 6));
39 if (checkSelect(inputs[0], inputs[2])) return;
40 Course findcourse = checkCourse(inputs[2]);
41 if (findcourse == null) {
42 System.out.println(inputs[2] + " does not exist");
43 return;
44 } else if ((findcourse.getMethod().equals("考试") && inputs.length != 5)
45 || (findcourse.getMethod().equals("考察") && inputs.length != 4)) {
46 System.out.println(inputs[0] + ' ' + inputs[1] + " : access mode mismatch");
47 } else {
48 SelectCourse newSelectCourse = new SelectCourse();
49 newSelectCourse.setCourse(findcourse);
50 Grade grade;
51 if (findcourse.getMethod().equals("考试")) {
52 ExamGrade examGrade = new ExamGrade();
53 examGrade.setUsualGrade(Integer.parseInt(inputs[3]));
54 examGrade.setFinalGrade(Integer.parseInt(inputs[4]));
55 grade = examGrade;
56 } else {
57 NoExamGrade noExamGrade = new NoExamGrade();
58 noExamGrade.setFinalGrade(Integer.parseInt(inputs[3]));
59 grade = noExamGrade;
60 }
61 newSelectCourse.setGrade(grade);
62 newSelectCourse.setStudent(newStudent);
63 selectCourses.add(newSelectCourse);
64 }
65 } else {
66 System.out.println("wrong format");
67 }
68 }
69 private Course checkCourse(String courseName) {
70 for (Course course : courses) {
71 if (course.getName().equals(courseName)) return course;
72 }
73 return null;
74 }
75
76 private boolean checkStudent(String num) {
77 for (Student student : students) {
78 if (student.getNum().equals(num)) return true;
79 }
80 return false;
81 }
82
83 private boolean checkClass(String classnum) {
84 for (String cname : Class) {
85 if (cname.equals(classnum)) return true;
86 }
87 return false;
88 }
89
90 private boolean checkSelect(String stunum, String cname) {
91 for (SelectCourse selectCourse : selectCourses) {
92 if (selectCourse.getStudent().getNum().equals(stunum)
93 && selectCourse.getCourse().getName().equals(cname)) return true;
94 }
95 return false;
96 }
97
98 public void ShowSave() {
99 for (Student student : students) System.out.println(student);
100 System.out.println("---------");
101 for (Course course : courses) System.out.println(course);
102 System.out.println("---------");
103 for (SelectCourse selectCourse : selectCourses) System.out.println(selectCourse);
104 }
105
106
107 public void studentScore() {
108 for (Student student : students) {
109 double sum = 0;
110 int count = 0;
111 for (SelectCourse selectCourse : selectCourses) {
112 if (selectCourse.getStudent().getNum().equals(student.getNum())) {
113 sum += selectCourse.getGrade().getTotalGrade();
114 count++;
115 }
116 }
117 if (count == 0) System.out.println(student.getNum() + ' ' + student.getName() + " did not take any exams");
118 else System.out.println(student.getNum() + ' ' + student.getName() + ' ' + (int) (sum / count));
119 }
120 }
121
122 public void CourseScore() {
123 for (Course course : courses) {
124 double sumUsualScore = 0;
125 double sumFinalScore = 0;
126 double sumTotalScore = 0;
127 int count = 0;
128 for (SelectCourse selectCourse : selectCourses) {
129 if (selectCourse.getCourse().getName().equals(course.getName())) {
130 count++;
131 sumTotalScore += selectCourse.getGrade().getTotalGrade();
132 sumFinalScore += selectCourse.getGrade().getFinalGrade();
133 if (selectCourse.getCourse().getMethod().equals("考试")) {
134 sumUsualScore += selectCourse.getGrade().getUsualGrade();
135 }
136 }
137 }
138 if (count == 0) System.out.println(course.getName() + " has no grades yet");
139 else if (course.getMethod().equals("考试"))
140 System.out.println(course.getName() + ' ' + (int) (sumUsualScore / count) + ' ' + (int) (sumFinalScore / count) + ' ' + (int) (sumTotalScore / count));
141 else if (course.getMethod().equals("考察"))
142 System.out.println(course.getName() + ' ' + (int) (sumFinalScore / count) + ' ' + (int) (sumTotalScore / count));
143 }
144 }
145
146 public void ClassScore() {
147 for (String classnum : Class) {
148 double sum = 0;
149 int count = 0;
150 for (SelectCourse selectCourse : selectCourses) {
151 if (selectCourse.getStudent().getNum().substring(0, 6).equals(classnum)) {
152 sum += selectCourse.getGrade().getTotalGrade();
153 count++;
154 }
155 }
156 if (count == 0) System.out.println(classnum + " has no grades yet");
157 else System.out.println(classnum + ' ' + (int) (sum / count));
158 }
159 }
160
161 public void MySort() {
162 students.sort(Comparator.comparing(Student::getNum));
163 Collator instance = Collator.getInstance(Locale.CHINA);
164 courses.sort((x, y) -> instance.compare(x.getName(), y.getName()));
165 Collections.sort(Class);
166 }
167
168 }
169
170
171 abstract class Grade {
172 double totalGrade;
173
174 public double getTotalGrade() {
175 return totalGrade;
176 }
177
178 public void setTotalGrade(int totalGrade) {
179 this.totalGrade = totalGrade;
180 }
181
182 public int getUsualGrade() {
183 return 0;
184 }
185
186 public int getFinalGrade() {
187 return 0;
188 }
189 }
190
191 class ExamGrade extends Grade {
192 int usualGrade;
193 int finalGrade;
194
195 public double getTotalGrade() {
196 return (0.3 * this.getUsualGrade() + 0.7 * this.getFinalGrade());
197 }
198
199 public int getUsualGrade() {
200 return usualGrade;
201 }
202
203 public void setUsualGrade(int usualGrade) {
204 this.usualGrade = usualGrade;
205 }
206
207 public int getFinalGrade() {
208 return finalGrade;
209 }
210
211 public void setFinalGrade(int finalGrade) {
212 this.finalGrade = finalGrade;
213 }
214 }
215
216 class NoExamGrade extends Grade {
217 private int finalGrade;
218
219 public double getTotalGrade() {
220 return finalGrade;
221 }
222
223 public int getFinalGrade() {
224 return finalGrade;
225 }
226
227 public void setFinalGrade(int finalGrade) {
228 this.finalGrade = finalGrade;
229 }
230 }
231
232 class Course {
233 private String name;
234 private String kind; // 课程种类
235 private String method; // 考核方式
236
237 public Course(String name, String kind, String method) {
238 this.name = name;
239 this.kind = kind;
240 this.method = method;
241 }
242
243 public String getName() {
244 return name;
245 }
246
247 public void setName(String name) {
248 this.name = name;
249 }
250
251 public String getKind() {
252 return kind;
253 }
254
255 public void setKind(String kind) {
256 this.kind = kind;
257 }
258
259 public String getMethod() {
260 return method;
261 }
262
263 public void setMethod(String method) {
264 this.method = method;
265 }
266 }
267
268
269 class Student {
270 private String num;
271 private String name;
272
273 public Student(String num, String name) {
274 this.num = num;
275 this.name = name;
276 }
277
278 public String getNum() {
279 return num;
280 }
281
282 public void setNum(String num) {
283 this.num = num;
284 }
285
286 public String getName() {
287 return name;
288 }
289
290 public void setName(String name) {
291 this.name = name;
292 }
293 }
294
295 class SelectCourse {
296 private Course course;
297 private Student student;
298 private Grade grade;
299
300 public Course getCourse() {
301 return course;
302 }
303
304 public void setCourse(Course course) {
305 this.course = course;
306 }
307
308 public Student getStudent() {
309 return student;
310 }
311
312 public void setStudent(Student student) {
313 this.student = student;
314 }
315
316 public Grade getGrade() {
317 return grade;
318 }
319
320 public void setGrade(Grade grade) {
321 this.grade = grade;
322 }
323 }
324
325
326
327 class InputMatching {
328 private static final String STU_NUM_MATCHING = "[0-9]{8}"; // 8个0-9的数字
329 private static final String STU_NAME_MATCHING = "\\S{1,10}"; // 1到10个非空格（TAB）字符
330 private static final String SCORE_MATCHING = "(\\d|[1-9]\\d|100)";
331 private static final String COURSE_NAME_MATCHING = "\\S{1,10}"; // 1到10个非空格（TAB）字符
332 private static final String COURSE_TYPE_MATCHING = "(选修|必修)";
333 private static final String CHECK_COURSE_TYPE_MATCHING = "(考试|考察)";
334 // cousrInput用于定义课程信息模式（正则表达式）
335 private static final String COURSE_INPUT = COURSE_NAME_MATCHING + " " + COURSE_TYPE_MATCHING + " " + CHECK_COURSE_TYPE_MATCHING;
336 // scoreInput用于定义成绩信息模式（正则表达式）
337 private static final String SCORE_INPUT = STU_NUM_MATCHING + " " + STU_NAME_MATCHING + " " + COURSE_NAME_MATCHING + " " +
338 SCORE_MATCHING + "(\\s" + SCORE_MATCHING + ")?";
339
340 public static int matchingInput(String s) {
341 if (matchingCourse(s)) {
342 return 1;
343 }
344 if (matchingScore(s)) {
345 return 2;
346 }
347 return 0;
348 }
349
350 private static boolean matchingCourse(String s) {
351 return s.matches(COURSE_INPUT);
352 }
353
354 private static boolean matchingScore(String s) {
355 return s.matches(SCORE_INPUT);
356 }
357 }
2、源码分析：
包含两个类：Main和ParseInput。Main类中有一个main方法，它是程序的入口点。在这个方法中，首先创建了一个Scanner对象s来读取用户输入，然后创建了一个ParseInput对象handle来处理输入。接下来，程序进入一个循环，每次循环都会读取一行输入并将其传递给handle.parseInput()方法进行处理，直到用户输入"end"为止。最后，调用了几个方法来对数据进行排序和输出。
在ParseInput类中，定义了四个私有成员变量：selectCourses, courses, students, 和 Class。这些变量分别表示选课信息、课程信息、学生信息和班级信息。在这个类中还定义了一个公共方法parseInput()，它接受一个字符串作为参数，并根据输入的内容进行相应的处理。
在这个方法中，首先将输入字符串按空格分割成字符串数组，并使用InputMatching.matchingInput()方法来确定输入类型。如果输入类型为1，则表示输入的是课程信息；如果输入类型为2，则表示输入的是选课信息；否则输出"wrong format"。
对于课程信息，首先检查课程是否已经存在，如果不存在，则根据输入的信息创建一个新的课程对象并添加到课程列表中。对于选课信息，首先检查学生是否已经存在，如果不存在，则创建一个新的学生对象并添加到学生列表中。然后检查班级是否已经存在，如果不存在，则添加到班级列表中。接下来检查选课信息是否已经存在，如果不存在，则根据输入的信息创建一个新的选课对象并添加到选课列表中。
这段代码还包含一些其他的私有方法，用于检查课程、学生和选课信息是否已经存在。
类图：
第七次PTA作业：
1、设计分析：
题目要求输入课程信息和学生成绩信息，然后根据给定的规则计算并输出学生的总成绩平均分、单门课程成绩平均分、班级所有课程总成绩平均分。题目还给出了一些异常情况的处理方法。
为了实现这道题目，可以定义几个类来存储和处理数据。可以定义一个Course类来存储课程信息，包括课程名称、课程性质和考核方式。可以定义一个Student类来存储学生信息，包括学号、姓名和成绩信息。成绩信息可以用一个Map来存储，其中键为课程名称，值为成绩。
在读取输入数据时，需要根据输入格式解析数据并将其存储到相应的类中。在读取课程信息时，需要检查课程性质和考核方式是否匹配，并处理异常情况。在读取成绩信息时，需要检查课程名称是否存在，并处理异常情况。
在计算学生的总成绩平均分时，需要遍历每个学生的成绩信息，并根据题目中给定的规则计算每门课程的总成绩。然后将所有课程的总成绩累加起来，除以课程数量得到学生的总成绩平均分。
在计算单门课程成绩平均分时，需要遍历所有学生的成绩信息，并根据题目中给定的规则计算每个学生的单门课程成绩。然后将所有学生的单门课程成绩累加起来，除以学生数量得到单门课程成绩平均分。
在计算班级所有课程总成绩平均分时，需要遍历所有学生的成绩信息，并根据题目中给定的规则计算每个学生的总成绩。然后将所有学生的总成绩累加起来，除以学生数量得到班级所有课程总成绩平均分。
最后，在输出结果时，需要按照题目中给定的格式输出结果，并处理异常情况。
1 import java.text.Collator;
2 import java.util.ArrayList;
3 import java.util.Collections;
4 import java.util.Comparator;
5 import java.util.Scanner;
6 public class main {
7 static boolean isNumber(String str) {
8 return str.matches("\\d+");
9 }
10
11 public static void main(String[] args) {
12 Scanner input=new Scanner(System.in);
13 String str="";
14 studentList students=new studentList();
15 InputMatching matching=new InputMatching();
16 chooseCourseList choose=new chooseCourseList();
17 Cls cls=new Cls();
18 courseList course=new courseList();
19 String str1,str2,str3;
20 while (true) {
21 String inputLine = input.nextLine();
22 if (inputLine.equals("end")) {
23 break;
24 }
25 String[] inputParts = inputLine.split(" ");
26 String studentNumber = inputParts[0];
27 String studentName = inputParts[1];
28 String subject = inputParts[2];
29 int grade = Integer.parseInt(inputParts[3]);
30 if (InputMatching.matchingInput(studentNumber + " " + studentName + " " + subject + " " + grade) != 2 && InputMatching.matchingInput(studentNumber + " " + studentName + " " + subject + " " + grade) != 3 && course.searchQuality(subject) != 2) {
31 System.out.println("wrong format");
32 continue;
33 }
34 if (grade < 4 || grade > 9 && inputParts.length > 5) {
35 System.out.println("wrong format");
36 continue;
37 }
38 String classId = studentNumber.substring(0, 6);
39 if (!cls.searchCls(classId)) {
40 cls.cls.add(cls.addCls(classId));
41 }
42 students.stu.add(students.addStudent(studentNumber, studentName));
43 }
44
45 String number,name,subject;
46 int UsualGrades,FinalGrades;
47 boolean flag=false;
48 while (!str.equals("end")) {
49 if (flag) {
50 str = input.nextLine();
51 }
52 flag = true;
53 if (str.equals("end")) {
54 break;
55 }
56 String ssr = str.split(" ")[0] + " " + str.split(" ")[1] + " " + str.split(" ")[2] + " " + str.split(" ")[3];
57 if (InputMatching.matchingInput(ssr) != 2 && InputMatching.matchingInput(ssr) != 3 && course.searchQuality(str.split(" ")[2]) != 2) {
58 System.out.println("wrong format");
59 continue;
60 }
61 if (((Integer.parseInt(str.split(" ")[3])) < 4 || (Integer.parseInt(str.split(" ")[3])) > 9) && str.split(" ").length > 5) {
62 System.out.println("wrong format");
63 continue;
64 }
65 number = str.split(" ")[0];
66 String Class = number.substring(0, 6);
67 if (!cls.searchCls(Class)) {
68 cls.cls.add(cls.addCls(Class));
69 }
70 name = str.split(" ")[1];
71 students.stu.add(students.addStudent(number, name));
72 subject = str.split(" ")[2];
73 try {
74 if (course.searchQuality(subject) == 1) {
75 UsualGrades = Integer.parseInt(str.split(" ")[3]);
76 if (choose.searchCourse(subject) && choose.searchId(number)) {
77 continue;
78 }
79 FinalGrades = Integer.parseInt(str.split(" ")[4]);
80 students.students.add(students.addStudentCompulsory(number, name, subject, UsualGrades, FinalGrades));
81 } else if (course.searchQuality(subject) == 0) {
82 UsualGrades = Integer.parseInt(str.split(" ")[3]);
83 if (choose.searchCourse(subject) && choose.searchId(number)) {
84 continue;
85 }
86 if (str.split(" ").length > 4) {
87 System.out.println(number + " " + name + " : access mode mismatch");
88 continue;
89 }
90 students.students.add(students.addStudentTake(number, name, subject, UsualGrades));
91 } else if (course.searchQuality(subject) == -1) {
92 System.out.println(subject + " does not exist");
93 } else if (course.searchQuality(subject) == 2) {
94 int testNumber = Integer.parseInt(str.split(" ")[3]);
95 if (str.split(" ").length - 4 != testNumber) {
96 System.out.println(number + " " + name + " : access mode mismatch");
97 continue;
98 }
99 int sum = 0;
100 for (int i = 0; i < testNumber; i++) {
101 sum += Integer.parseInt(str.split(" ")[4 + i]);
102 }
103 sum /= testNumber;
104 students.students.add(students.addExperimentalGrades(number, name, subject, sum));
105 }
106 } catch (ArrayIndexOutOfBoundsException e) {
107 System.out.println(number + " " + name + " : access mode mismatch");
108 }
109 }
110
111 chooseCourseList chooses=new chooseCourseList();
112 chooses.getAverageGrade(students,course,cls);
113 }
114 }
115
116
117
118 class student {
119 int experimentalGrades;
120 String number;
121 String name;
122 String course;
123 int UsualGrades = 0;
124 int FinalGrades = 0;
125 String Class;
126 int grade = 0;
127
128 public static Comparator<student> getNumberComparator() {
129 return new Comparator<student>() {
130 @Override
131 public int compare(student s1, student s2) {
132 return s1.number.compareTo(s2.number);
133 }
134 };
135 }
136 }
137
138 class course {
139 String name;
140 String quality;
141 String manner;
142
143 public static Comparator<course> getChineseNameComparator() {
144 final Collator collator = Collator.getInstance(java.util.Locale.CHINA);
145 return (c1, c2) -> collator.compare(c1.name, c2.name);
146 }
147 }
148
149 class courseList {
150 ArrayList<course> courses = new ArrayList<>();
151
152 boolean searchCourse(String courseName) {
153 return courses.stream().anyMatch(c -> c.name.equals(courseName));
154 }
155
156 course addCourse(String name, String quality, String manner) {
157 course newCourse = new course();
158 newCourse.name = name;
159 newCourse.quality = quality;
160 newCourse.manner = manner;
161 return newCourse;
162 }
163
164 int searchQuality(String subject) {
165 for (course c : courses) {
166 if (c.name.equals(subject)) {
167 if (c.quality.equals("必修") || c.manner.equals("考试")) {
168 return 1;
169 } else if (c.quality.equals("实验") || c.manner.equals("实验")) {
170 return 2;
171 } else {
172 return 0;
173 }
174 }
175 }
176 return -1;
177 }
178 }
179
180 class studentList {
181 ArrayList<student> students = new ArrayList<>();
182 ArrayList<student> stu = new ArrayList<>();
183
184 student addStudentCompulsory(String studentNumber, String studentName, String courseName, int usualGrades, int finalGrades) {
185 student newStudent = new student();
186 chooseCourseList newChoose = new chooseCourseList();
187 newStudent.name = studentName;
188 if (chooseCourseList.searchCourse(courseName) && chooseCourseList.chooseCourse.get(chooseCourseList.searchCourseInt(courseName)).name.equals(studentName) && chooseCourseList.chooseCourse.get(chooseCourseList.searchCourseInt(courseName)).number.equals(studentNumber)) {
189 return null;
190 }
191 Cls newCls = new Cls();
192 newStudent.number = studentNumber;
193 newStudent.course = courseName;
194 newStudent.grade = (int) (finalGrades * 0.7 + usualGrades * 0.3);
195 String classId = studentNumber.substring(0, 6);
196 if (!newCls.searchCls(classId)) {
197 newCls.cls.add(newCls.addCls(classId));
198 }
199 chooseCourseList.chooseCourse.add(newChoose.addChoose(studentNumber, studentName, courseName, classId, usualGrades, finalGrades, newStudent.grade));
200 return newStudent;
201 }
202
203 student addStudentTake(String studentNumber, String studentName, String courseName, int usualGrades) {
204 student newStudent = new student();
205 newStudent.name = studentName;
206 newStudent.number = studentNumber;
207 newStudent.course = courseName;
208 newStudent.grade = usualGrades;
209 String classId = studentNumber.substring(0, 6);
210 chooseCourseList newChoose = new chooseCourseList();
211 if (chooseCourseList.searchCourse(courseName) && chooseCourseList.chooseCourse.get(chooseCourseList.searchCourseInt(courseName)).name.equals(studentName) && chooseCourseList.chooseCourse.get(chooseCourseList.searchCourseInt(courseName)).number.equals(studentNumber)) {
212 return null;
213 }
214 chooseCourseList.chooseCourse.add(newChoose.addChooseTake(studentNumber, studentName, courseName, classId, usualGrades, newStudent.grade));
215 return newStudent;
216 }
217
218 student addExperimentalGrades(String studentNumber, String studentName, String courseName, int experimentalGrades) {
219 student newStudent = new student();
220 newStudent.name = studentName;
221 newStudent.number = studentNumber;
222 newStudent.course = courseName;
223 newStudent.experimentalGrades = experimentalGrades;
224 newStudent.grade = experimentalGrades;
225 String classId = studentNumber.substring(0, 6);
226 chooseCourseList newChoose = new chooseCourseList();
227 if (chooseCourseList.searchCourse(courseName) && chooseCourseList.chooseCourse.get(chooseCourseList.searchCourseInt(courseName)).name.equals(studentName) && chooseCourseList.chooseCourse.get(chooseCourseList.searchCourseInt(courseName)).number.equals(studentNumber)) {
228 return null;
229 }
230 chooseCourseList.chooseCourse.add(newChoose.addChooseExperimental(studentNumber, studentName, courseName, classId, experimentalGrades,newStudent.grade));
231 return newStudent;
232 }
233
234 student addStudent(String studentNumber, String studentName) {
235 student newStudent = new student();
236 newStudent.number = studentNumber;
237 newStudent.name = studentName;
238 return newStudent;
239 }
240
241 boolean searchStudent(String studentName) {
242 for (student s : students) {
243 if (s.name.equals(studentName)) {
244 return true;
245 }
246 }
247 return false;
248 }
249
250
251
252 }
253
254
255 class Cls {
256 private static int nextIndex = 0;
257 String id;
258 private int index;
259
260 ArrayList<Cls> cls = new ArrayList<>();
261
262 public Cls addCls(String classId) {
263 Cls newCls = new Cls();
264 newCls.id = classId;
265 newCls.index = nextIndex++;
266 cls.add(newCls);
267 return newCls;
268 }
269
270 public boolean searchCls(String classId) {
271 for (int i = 0; i < cls.size(); i++) {
272 if (cls.get(i).id.equals(classId)) {
273 return true;
274 }
275 }
276 return false;
277 }
278
279 public static Comparator<Cls> getIndexComparator() {
280 return new Comparator<Cls>() {
281 @Override
282 public int compare(Cls c1, Cls c2) {
283 return c1.id.compareTo(c2.id);
284 }
285 };
286 }
287 }
288
289
290 class InputMatching {
291 static String studentNumberPattern = "[0-9]{8}";
292 static String studentNamePattern = "\\S{1,10}";
293 static String scorePattern = "([1-9]?[0-9]|100)";
294 static String courseNamePattern = "\\S{1,10}";
295 static String courseTypePattern = "(选修|必修|实验)";
296 static String checkCourseTypePattern = "(考试|考察|实验)";
297
298 static String courseInputPattern = courseNamePattern + " " + courseTypePattern + " " + checkCourseTypePattern;
299 static String scoreInputPattern1 = studentNumberPattern + " " + studentNamePattern + " " + courseNamePattern + " " +
300 scorePattern + "(scoreMatching)?";
301 static String scoreInputPattern2 = studentNumberPattern + " " + studentNamePattern + " " + courseNamePattern + " " +
302 scorePattern + "(scoreMatching)?"+" "+scorePattern + "(scoreMatching)?";
303
304 public static int matchingInput(String input) {
305 if (matchingCourse(input)) {
306 return 1;
307 }
308 if (matchingScore1(input)) {
309 return 2;
310 }
311 if (matchingScore2(input)) {
312 return 3;
313 }
314 return 0;
315 }
316
317 static boolean matchingCourse(String input) {
318 return input.matches(courseInputPattern);
319 }
320
321 static boolean matchingScore1(String input) {
322 return input.matches(scoreInputPattern1);
323 }
324
325 static boolean matchingScore2(String input) {
326 return input.matches(scoreInputPattern2);
327 }
328 }
329
330 class chooseCourseList{
331 static ArrayList<student> chooseCourse = new ArrayList<>();
332
333 static boolean searchId(String studentNumber) {
334 for (student s : chooseCourse) {
335 if (s.number.equals(studentNumber)) {
336 return true;
337 }
338 }
339 return false;
340 }
341
342 static boolean searchCourse(String courseName) {
343 for (int i = 0; i < chooseCourse.size(); i++) {
344 if (chooseCourse.get(i).course.equals(courseName)) {
345 return true;
346 }
347 }
348 return false;
349 }
350
351 static int searchCourseInt(String courseName) {
352 for (int i = 0; i < chooseCourse.size(); i++) {
353 if (chooseCourse.get(i).course.equals(courseName)) {
354 return i;
355 }
356 }
357 return -1;
358 }
359
360 static boolean searchClass(String classId) {
361 for (int i = 0; i < chooseCourse.size(); i++) {
362 if (chooseCourse.get(i).Class.equals(classId)) {
363 return true;
364 }
365 }
366 return false;
367 }
368
369 student addChoose(String studentNumber, String studentName, String courseName, String classId, int usualGrades, int finalGrades, int grade) {
370 student newStudent = new student();
371 newStudent.Class = classId;
372 newStudent.number = studentNumber;
373 newStudent.name = studentName;
374 newStudent.course = courseName;
375 newStudent.UsualGrades = usualGrades;
376 newStudent.FinalGrades = finalGrades;
377 newStudent.grade = grade;
378 return newStudent;
379 }
380
381 student addChooseTake(String id,String name,String course,String Class,int UsualGrades,int grade )
382 {
383 student newStudent=new student();
384 newStudent.Class=Class;
385 newStudent.number=id;
386 newStudent.name=name;
387 newStudent.course=course;
388 newStudent.UsualGrades=UsualGrades;
389 newStudent.grade=grade;
390 return newStudent;
391 }
392 student addChooseExperimental(String studentNumber, String studentName, String courseName, String classId, int experimentalGrades, int grade) {
393 student newStudent = new student();
394 newStudent.Class = classId;
395 newStudent.number = studentNumber;
396 newStudent.name = studentName;
397 newStudent.course = courseName;
398 newStudent.experimentalGrades = experimentalGrades;
399 newStudent.grade = experimentalGrades;
400 return newStudent;
401 }
402
403 public int getAverageGrades(String studentNumber) {
404 int sum = 0, count = 0;
405 for (int i = 0; i < chooseCourse.size(); i++) {
406 if (chooseCourse.get(i).number.equals(studentNumber)) {
407 sum += chooseCourse.get(i).grade;
408 count++;
409 }
410 }
411 return sum / count;
412 }
413
414 public int getAverageCourseUsualGrades(String courseName) {
415 int sum = 0, count = 0;
416 for (int i = 0; i < chooseCourse.size(); i++) {
417 if (chooseCourse.get(i).course.equals(courseName)) {
418 sum += chooseCourse.get(i).UsualGrades;
419 count++;
420 }
421 }
422 return sum / count;
423 }
424
425 public int getAverageCourseFinalGrades(String courseName) {
426 int sum = 0, count = 0;
427 for (int i = 0; i < chooseCourse.size(); i++) {
428 if (chooseCourse.get(i).course.equals(courseName)) {
429 sum += chooseCourse.get(i).FinalGrades;
430 count++;
431 }
432 }
433 return sum / count;
434 }
435
436 public int getAverageCourseGrades(String courseName) {
437 int sum = 0, count = 0;
438 for (int i = 0; i < chooseCourse.size(); i++) {
439 if (chooseCourse.get(i).course.equals(courseName)) {
440 sum += chooseCourse.get(i).grade;
441 count++;
442 }
443 }
444 return sum / count;
445 }
446
447 public int getAverageExperimentalGrades(String courseName) {
448 int sum = 0, count = 0;
449 for (int i = 0; i < chooseCourse.size(); i++) {
450 if (chooseCourse.get(i).course.equals(courseName)) {
451 sum += chooseCourse.get(i).experimentalGrades;
452 count++;
453 }
454 }
455 return sum / count;
456 }
457
458 public int getClassAverageGrades(String classId) {
459 int sum = 0, count = 0;
460 for (int i = 0; i < chooseCourse.size(); i++) {
461 if (chooseCourse.get(i).Class.equals(classId)) {
462 sum += chooseCourse.get(i).grade;
463 count++;
464 }
465 }
466 return sum / count;
467 }
468
469
470 public void getAverageGrade(studentList students, courseList courses, Cls cls) {
471 Collections.sort(students.stu, student.getNumberComparator());
472 Collections.sort(cls.cls, Cls.getIndexComparator());
473 Collections.sort(courses.courses, course.getChineseNameComparator());
474
475 for (int i = 0; i < students.stu.size(); i++) {
476 int flag = 0;
477 for (int j = 0; j < i; j++) {
478 if (students.stu.get(j).number.equals(students.stu.get(i).number)) {
479 flag = 1;
480 break;
481 }
482 }
483 if (flag == 1) {
484 continue;
485 }
486 if (searchId(students.stu.get(i).number)) {
487 System.out.println(students.stu.get(i).number + " " + students.stu.get(i).name + " " + getAverageGrades(students.stu.get(i).number));
488 } else {
489 System.out.println(students.stu.get(i).number + " " + students.stu.get(i).name + " did not take any exams");
490 }
491 }
492
493 for (int i = 0; i < courses.courses.size(); i++) {
494 if (searchCourse(courses.courses.get(i).name)) {
495 if (courses.courses.get(i).manner.equals("考试")) {
496 System.out.println(courses.courses.get(i).name + " " + getAverageCourseUsualGrades(courses.courses.get(i).name)
497 + " " + getAverageCourseFinalGrades(courses.courses.get(i).name) + " " + getAverageCourseGrades(courses.courses.get(i).name));
498 } else if (courses.courses.get(i).manner.equals("考察")) {
499 System.out.println(courses.courses.get(i).name + " " + getAverageCourseUsualGrades(courses.courses.get(i).name)
500 + " " + getAverageCourseGrades(courses.courses.get(i).name));
501 } else {
502 System.out.println(courses.courses.get(i).name + " " + getAverageExperimentalGrades(courses.courses.get(i).name));
503 }
504 } else {
505 System.out.println(courses.courses.get(i).name + " has no grades yet");
506 }
507 }
508
509 for (int i = 0; i < cls.cls.size(); i++) {
510 int flag = 0;
511 for (int j = 0; j < i; j++) {
512 if (cls.cls.get(j).equals(cls.cls.get(i))) {
513 flag = 1;
514 break;
515 }
516 }
517 if (flag == 1) {
518 continue;
519 }
520 if (searchClass(cls.cls.get(i).id)) {
521 System.out.println(cls.cls.get(i).id + " " + getClassAverageGrades(cls.cls.get(i).id));
522 } else {
523 System.out.println(cls.cls.get(i).id + " has no grades yet");
524 }
525 }
526 }
527
528 }
2、源码分析：
主类 main，其中定义了一个静态方法 isNumber，用于检查一个字符串是否为数字。在 main 方法中，首先创建了一些对象，包括 Scanner 对象用于读取输入，studentList 对象用于管理学生列表，InputMatching 对象用于匹配输入，chooseCourseList 对象用于选择课程列表，Cls 对象用于管理班级，以及 courseList 对象用于管理课程列表。
接下来是一个循环，读取输入行并根据输入行的内容进行处理。如果输入行为 “end”，则退出循环。否则，将输入行分割成多个部分，并获取学生编号、学生姓名、科目和成绩。然后进行一些检查，如果输入格式不正确或者科目不合法，则输出 “wrong format” 并继续下一次循环。否则，获取班级编号并检查是否存在该班级，如果不存在，则添加该班级。最后将学生添加到学生列表中。
接下来是另一个循环，读取输入行并根据输入行的内容进行处理。如果输入行为 “end”，则退出循环。否则，进行一些检查，如果输入格式不正确或者科目不合法，则输出 “wrong format” 并继续下一次循环。然后获取学生编号、班级编号、学生姓名和科目，并检查是否存在该班级，如果不存在，则添加该班级。最后将学生添加到学生列表中。
类图：
第八次PTA作业：
1、设计分析：
这道题目要求修改类结构，将成绩类的继承关系改为组合关系。这意味着，成绩信息将由课程成绩类和分项成绩类组成。课程成绩类将组合分项成绩类，而分项成绩类由成绩分值和权重两个属性构成。
在完成课程成绩统计程序后，需要比较继承和组合关系的区别。继承是一种“是一个”的关系，即子类是父类的一种特殊形式。而组合是一种“有一个”的关系，即一个类包含另一个类的实例作为其属性。在这个例子中，组合关系更灵活，因为它允许我们更改分项成绩类而不影响课程成绩类。
要实现这个程序，首先需要定义课程成绩类和分项成绩类。然后，在课程成绩类中添加一个分项成绩类的实例作为其属性。接下来，需要根据题目要求实现相关的方法和逻辑，例如计算总成绩、输出结果等。
1 import java.text.Collator;
2 import java.util.*;
3 import java.util.ArrayList;
4 import java.util.stream.Collectors;
5
6 public class Main {
7 public static void main(String[] args) {
8 Scanner s = new Scanner(System.in);
9 ParseInput handle = new ParseInput();
10 String s_record;
11 while (!(s_record = s.nextLine()).equals("end")) {
12 handle.parseInput(s_record); // 解析用户输入的每一行数据
13 }
14 handle.showStudents();
15 handle.showCourses();
16 handle.showClasses();
17 }
18 }
19
20 class ParseInput{
21 ArrayList<Student> listStudent=new ArrayList<>();
22 ArrayList<Course> listCourse=new ArrayList<>();
23 ArrayList<Class> listClass=new ArrayList<>();
24 ArrayList<ChooseCourse> listChooseCourse=new ArrayList<>();
25
26 public void parseInput(String str) {
27 InputMatching mat = new InputMatching();
28 int flag = mat.matchingInput(str);
29 if (flag == 0) {
30 System.out.println("wrong format");
31 } else if (flag == 1) {
32 courseMessage(str);
33 } else if (flag == 2) {
34 gradeMessage(str);
35 }
36 }
37 public void courseMessage(String str) {
38 String[] letters = str.split(" ");
39 String courseName = letters[0]; // 课程名
40 String type = letters[1]; // 课程类型
41 String testType = letters[2]; // 课程考试类型
42 int num = Integer.parseInt(letters[3]);
43 if (letters.length - 4 != num) {
44 System.out.println(courseName + " : number of scores does not match");
45 return;
46 }
47 float totalPower = 0;
48 for (int i = 4; i < letters.length; i++) {
49 totalPower += Float.parseFloat(letters[i]);
50 }
51 if (totalPower != 1.0) {
52 System.out.println(courseName + " : weight value error");
53 return;
54 }
55 ArrayList<String> power = new ArrayList<>(Arrays.asList(letters).subList(4, letters.length));
56 Course course = new Course(courseName, type, testType, power);
57 if (checkCourse(course) && searchCourse(courseName) == null) {
58 listCourse.add(course);
59 }
60 }
61
62 public void gradeMessage(String str) {
63 String[] letters = str.split(" ");
64 String stuId = letters[0]; // 学生学号
65 String classID = letters[0].substring(0, 6);
66 String name = letters[1]; // 学生姓名
67 String courseName = letters[2]; // 课程名字
68
69 // 如果该班级第一次出现
70 if (searchClass(classID) == null) {
71 Class cla = new Class(classID);
72 listClass.add(cla);
73 }
74
75 Student stu = new Student(classID, stuId, name);
76 if (!searchStudent(stuId)) {
77 listStudent.add(stu); // 将学生加入列表中
78 }
79
80 Course course = searchCourse(courseName);
81 if (course == null) {
82 System.out.println(courseName + " does not exist");
83 return;
84 }
85
86 if (letters.length == 4 && course.testType.equals("考察")) {
87 int finalGrade = Integer.parseInt(letters[3]);
88 AssessGrade assessGrade = new AssessGrade(finalGrade);
89 ChooseCourse chooseCourse = new ChooseCourse(course, stu, assessGrade);
90 if (!searchChooseCourse(name, courseName)) {
91 listChooseCourse.add(chooseCourse);
92 }
93 } else if (letters.length == 5 && course.testType.equals("考试")) {
94 int usualGrade = Integer.parseInt(letters[3]);
95 int finalGrade = Integer.parseInt(letters[4]);
96 ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade, course.powers);
97 ChooseCourse chooseCourse = new ChooseCourse(course, stu, examGrade);
98 listChooseCourse.add(chooseCourse);
99 } else if (letters.length > 5 && course.testType.equals("实验")) {
100 int exNum = course.powers.size();
101 if (exNum != letters.length - 3) {
102 System.out.println(stuId + " " + name + " : access mode mismatch");
103 return;
104 }
105 ArrayList<Integer> scores = new ArrayList<>();
106 for (int i = 3; i < letters.length; i++) {
107 scores.add(Integer.parseInt(letters[i]));
108 }
109 ExperimentGrade experimentGrade = new ExperimentGrade(scores, course.powers);
110 ChooseCourse chooseCourse = new ChooseCourse(course, stu, experimentGrade);
111 listChooseCourse.add(chooseCourse);
112 } else {
113 System.out.println(stuId + " " + name + " : access mode mismatch");
114 }
115 }
116
117
118 public boolean checkCourse(Course course) {
119 String type = course.getType();
120 String testType = course.getTestType();
121 if (type.equals("必修") && testType.equals("考试")) {
122 return true;
123 } else if (type.equals("选修") && (testType.equals("考试") || testType.equals("考察"))) {
124 return true;
125 } else if (type.equals("实验") && testType.equals("实验")) {
126 return true;
127 } else {
128 System.out.println(course.getCourseName() + " : course type & access mode mismatch");
129 return false;
130 }
131 }
132
133 public Class searchClass(String classId) {
134 return listClass.stream()
135 .filter(cls -> cls.getClassId().equals(classId))
136 .findFirst()
137 .orElse(null);
138 }
139
140 public Course searchCourse(String name) {
141 return listCourse.stream()
142 .filter(course -> course.getCourseName().equals(name))
143 .findFirst()
144 .orElse(null);
145 }
146
147 public boolean searchStudent(String id) {
148 return listStudent.stream()
149 .anyMatch(stu -> stu.getId().equals(id));
150 }
151
152 // 查找是否有重复选课成绩
153 public boolean searchChooseCourse(String stuName, String courseName) {
154 return listChooseCourse.stream()
155 .anyMatch(cs -> cs.student.getStuName().equals(stuName) && cs.course.getCourseName().equals(courseName));
156 }
157
158 public void showStudents() {
159 Collections.sort(listStudent);
160 for (Student stu : listStudent) {
161 ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(stu.getId());
162 if (stuCourseSelects.size() != 0) {
163 System.out.println(stu.getId() + " " + stu.getStuName() + " " + getAvgTotalScore(stuCourseSelects));
164 } else {
165 System.out.println(stu.getId() + " " + stu.getStuName() + " did not take any exams");
166 }
167 }
168 }
169
170 //java 选修 考察
171 public void showCourses() {
172 Collections.sort(listCourse);
173 for (Course course : listCourse) {
174 ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getCourseName());
175 if (stuCourseSelects.size() != 0) {
176 System.out.println(course.getCourseName() + " " + getAvgTotalScore(stuCourseSelects));
177 } else {
178 System.out.println(course.courseName + " has no grades yet");
179 }
180 }
181 }
182
183 public void showClasses() {
184 Collections.sort(listClass);
185 for (Class cls : listClass) {
186 ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId());
187 if (stuCourseSelects.size() != 0) {
188 System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
189 } else {
190 System.out.println(cls.getClassId() + " has no grades yet");
191 }
192 }
193 }
194 public ArrayList<ChooseCourse> getStudentSelects(String id) {
195 return listChooseCourse.stream()
196 .filter(cos -> cos.student.getId().equals(id))
197 .collect(Collectors.toCollection(ArrayList::new));
198 }
199
200 public ArrayList<ChooseCourse> getCourseSelects(String courseName) {
201 return listChooseCourse.stream()
202 .filter(cos -> cos.course.getCourseName().equals(courseName))
203 .collect(Collectors.toCollection(ArrayList::new));
204 }
205
206 public ArrayList<ChooseCourse> getClassSelects(String clsId) {
207 return listChooseCourse.stream()
208 .filter(cos -> cos.student.getClsId().equals(clsId))
209 .collect(Collectors.toCollection(ArrayList::new));
210 }
211
212 public int getAvgTotalScore(ArrayList<ChooseCourse> cs) {
213 return (int) cs.stream()
214 .mapToInt(c -> c.grade.getTotalGrade())
215 .average()
216 .orElse(0);
217 }
218
219 public int getAvgUsualScore(ArrayList<ChooseCourse> cs) {
220 return (int) cs.stream()
221 .filter(c -> c.course.getTestType().equals("考试"))
222 .mapToInt(c -> c.grade.getUsualGrade())
223 .average()
224 .orElse(0);
225 }
226
227 public int getAvgFinalScore(ArrayList<ChooseCourse> cs) {
228 return (int) cs.stream()
229 .mapToInt(c -> c.grade.finalGrade)
230 .average()
231 .orElse(0);
232 }
233
234 }
235 class ChooseCourse {
236 Course course;
237 Student student;
238 Grade grade;
239
240 public ChooseCourse(Course course, Student student, Grade grade) {
241 this.course = course;
242 this.student = student;
243 this.grade = grade;
244 }
245 }
246
247 class Student implements Comparable<Student> {
248 String stuName;
249 String id;
250 String clsId;
251
252 public Student(String clsId, String id, String stuName) {
253 this.clsId = clsId;
254 this.id = id;
255 this.stuName = stuName;
256 }
257
258 public String getId() {
259 return id;
260 }
261
262 public String getStuName() {
263 return stuName;
264 }
265
266 public String getClsId() {
267 return clsId;
268 }
269
270 @Override
271 public int compareTo(Student stu) {
272 return getId().compareTo(stu.getId());
273 }
274 }
275
276 class Course implements Comparable<Course> {
277 String courseName;
278 String type;
279 String testType;
280 ArrayList<String> powers = new ArrayList<>();
281
282 public Course(String courseName, String type, String testType, ArrayList<String> powers) {
283 this.courseName = courseName;
284 this.type = type;
285 this.testType = testType;
286 this.powers = powers;
287 }
288
289 public String getCourseName() {
290 return courseName;
291 }
292
293 public String getType() {
294 return type;
295 }
296
297 public String getTestType() {
298 return testType;
299 }
300
301 @Override
302 public int compareTo(Course o) {
303 Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
304 return compare.compare(courseName, o.getCourseName());
305 }
306 }
307
308 class Class implements Comparable<Class> {
309 String classId;
310
311 public Class(String classId) {
312 this.classId = classId;
313 }
314
315 public String getClassId() {
316 return classId;
317 }
318
319 @Override
320 public int compareTo(Class o) {
321 return getClassId().compareTo(o.getClassId());
322 }
323 }
324
325 abstract class Grade {
326 int finalGrade;
327 ArrayList<String> powers = new ArrayList<>();
328
329 public abstract int getUsualGrade();
330
331 public abstract int getTotalGrade();
332 }
333
334 class ExamGrade extends Grade {
335 int usualGrade;
336 ArrayList<Float> powers = new ArrayList<>();
337
338 public ExamGrade(int usualGrade, int finalGrade, ArrayList<String> powers) {
339 super.finalGrade = finalGrade;
340 this.usualGrade = usualGrade;
341 super.powers = powers;
342 }
343
344 @Override
345 public int getUsualGrade() {
346 return usualGrade;
347 }
348
349 @Override
350 public int getTotalGrade() {
351 return (int) (usualGrade * powers.get(0) + finalGrade * powers.get(1));
352 }
353 }
354
355 class AssessGrade extends Grade {
356
357 public AssessGrade(int finalGrade) {
358 this.finalGrade = finalGrade;
359 }
360
361 @Override
362 public int getUsualGrade() {
363 return 0;
364 }
365
366 @Override
367 public int getTotalGrade() {
368 return finalGrade;
369 }
370 }
371
372 class ExperimentGrade extends Grade {
373 ArrayList<Integer> exGrade = new ArrayList<>(); // 成绩
374
375 public ExperimentGrade(ArrayList<Integer> scores, ArrayList<String> powers) {
376 exGrade = scores;
377 super.powers = powers;
378 }
379
380 @Override
381 public int getUsualGrade() {
382 return 0;
383 }
384
385 @Override
386 public int getTotalGrade() {
387 float sum = 0;
388 for (int i = 0; i < exGrade.size(); i++) {
389 sum += exGrade.get(i) * Float.parseFloat(powers.get(i));
390 }
391 return (int) sum;
392 }
393 }
394
395 class InputMatching {
396 static String stuNumMatching = "[0-9]{8}"; // 8个0-9的数字
397 static String stuNameMatching = "\\S{1,10}"; // 1到10个非空格（TAB）字符
398 static String scoreMatching = "([1-9]?[0-9]|100)";
399 static String experimentNum = "^[4-9]$";
400 static String coursePowerNum = "[1-9]";
401 static String powerNum = "(^[0-9]*\\.([0-9]{1}\\d*)$)|[1]"; // 小于或等于1的数
402 static String courseNameMatching = "\\S{1,10}"; // 1到10个非空格（TAB）字符
403 static String courseTypeMatching = "(选修|必修|实验)";
404 static String checkCourseTypeMatching = "(考试|考察|实验)";
405 // courseInput用于定义课程信息模式（正则表达式）
406 static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
407 // scoreInput用于定义成绩信息模式（正则表达式）
408 static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
409 scoreMatching;
410 static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
411 scoreMatching + " " + scoreMatching;
412 static String scoreInput3 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
413 experimentNum;
414
415 public int matchingInput(String s) {
416 if (matchingCourse(s)) {
417 return 1;
418 }
419 if (matchingScore(s) || matchingExScore(s)) {
420 return 2;
421 }
422 return 0;
423 }
424
425 // 课程信息
426 private static boolean matchingCourse(String s) {
427 String[] letters = s.split(" ");
428 if (letters[0].matches(courseNameMatching) && letters[1].matches(courseTypeMatching)
429 && letters[2].matches(checkCourseTypeMatching) && letters[3].matches(coursePowerNum)) {
430 if (letters[2].equals("实验") && (!letters[3].matches(experimentNum))) {
431 return false;
432 }
433 for (int i = 4; i < letters.length; i++) {
434 if (!letters[i].matches(powerNum)) {
435 return false;
436 }
437 }
438 return true;
439 }
440 return false;
441 }
442
443 // 成绩信息
444 private static boolean matchingScore(String s) {
445 if (s.matches(scoreInput1) || s.matches(scoreInput2)) {
446 return true;
447 }
448 return false;
449 }
450
451 // 实验课信息
452 private static boolean matchingExScore(String s) {
453 String[] letters = s.split(" ");
454 if (letters[0].matches(stuNumMatching) && letters[1].matches(stuNameMatching) && letters[2].matches(courseNameMatching)) {
455 for (int i = 3; i < letters.length; i++) {
456 if (!letters[i].matches(scoreMatching)) {
457 return false;
458 }
459 }
460 return true;
461 }
462 return false;
463 }
464 }
2、源码分析：
Main类中有一个main方法，它是程序的入口点。在这个方法中，首先创建了一个Scanner对象s来读取用户输入。然后创建了一个ParseInput对象handle来处理用户输入的数据。接下来，使用一个循环来读取用户输入的每一行数据，直到用户输入"end"为止。在循环中，每次读取一行数据并将其传递给handle.parseInput()方法进行解析。最后，调用handle.showStudents()、handle.showCourses()和handle.showClasses()方法来显示学生、课程和班级信息。
ParseInput类中包含了几个实例变量：listStudent、listCourse、listClass和listChooseCourse。它们分别用来存储学生、课程、班级和选课信息。
在这个类中，有一个重要的方法叫做parseInput()。这个方法接收一个字符串参数，表示用户输入的一行数据。在这个方法中，首先创建了一个InputMatching对象，并调用它的matchingInput()方法来判断用户输入的数据格式是否正确。如果格式不正确，则输出"wrong format"；否则根据返回值判断是课程信息还是成绩信息，并调用相应的方法进行处理。
如果是课程信息，则调用courseMessage()方法来处理课程信息。在这个方法中，首先使用split()方法将输入的字符串按空格分割成字符串数组。然后从数组中提取出课程名、课程类型、课程考试类型和成绩数量等信息。接下来，检查输入的成绩数量是否与实际输入的成绩数量相符，如果不相符，则输出错误信息并返回。然后计算所有成绩的权重之和，如果权重之和不为1，则输出错误信息并返回。最后，将输入的成绩权重存储到一个ArrayList中，并创建一个新的Course对象。如果这个课程不存在且满足检查条件，则将其添加到课程列表中。
如果是成绩信息，则调用gradeMessage()方法来处理成绩信息。在这个方法中，首先使用split()方法将输入的字符串按空格分割成字符串数组。然后从数组中提取出学生学号、班级编号、学生姓名和课程名等信息。接下来，检查班级是否已经存在，如果不存在，则创建一个新的班级对象并将其添加到班级列表中。然后创建一个新的学生对象，如果这个学生不存在，则将其添加到学生列表中。最后，检查课程是否存在，如果不存在，则输出错误信息并返回。
类图：
三、踩坑心得：
-
输入数据的格式检查：在parseInput()方法中，需要检查用户输入的数据格式是否正确。这需要编写一个InputMatching类来实现。在这个类中，需要编写一个matchingInput()方法来判断用户输入的数据格式是否正确。这个方法的实现可能会比较复杂，需要仔细设计和测试。例如，需要考虑各种不同的输入格式，以及如何准确地判断它们是否符合要求。
-
数据的存储和管理：在ParseInput类中，需要使用多个ArrayList来存储学生、课程、班级和选课信息。在处理用户输入的数据时，需要对这些列表进行增删改查操作。这些操作需要仔细设计和实现，以避免出现错误。例如，在添加新的学生、课程或班级时，需要检查它们是否已经存在；在查询学生、课程或班级信息时，需要考虑如何快速地查找到相应的数据。
-
错误处理：在处理用户输入的数据时，可能会出现各种错误情况，例如输入的成绩数量不匹配、权重之和不为1、课程不存在等。需要在代码中对这些错误情况进行检查，并输出相应的错误信息。这部分代码需要仔细设计和测试，以确保能够准确地捕获并处理各种错误情况。
-
代码的可读性和可维护性：上述代码包含了多个类和方法，实现了较为复杂的功能。为了提高代码的可读性和可维护性，需要对代码进行良好的组织和规划，合理地划分模块和功能，并编写清晰易懂的注释。此外，在编写代码时，应该注意遵循一些良好的编程实践，例如使用有意义的变量名、避免过长的方法和过深的嵌套等。
四、改进意见：
-
输入数据的格式检查：为了更好地检查用户输入的数据格式是否正确，可以考虑使用正则表达式来实现。正则表达式是一种强大的文本匹配工具，可以用来准确地判断用户输入的数据格式是否符合要求。在InputMatching类中，可以编写一个matchingInput()方法，使用正则表达式来判断用户输入的数据格式是否正确。
-
数据的存储和管理：为了更好地存储和管理数据，可以考虑使用更加高效的数据结构来替换ArrayList。例如，可以使用HashMap来存储学生、课程和班级信息，这样在查询时就可以快速地查找到相应的数据。此外，在处理用户输入的数据时，应该注意避免重复操作，以提高代码的效率。
-
错误处理：为了更好地处理错误情况，可以考虑使用异常处理机制来实现。在代码中，可以定义一些自定义异常类，用来表示各种不同的错误情况。然后，在处理用户输入的数据时，如果遇到错误情况，则抛出相应的异常。在main方法中，可以使用try-catch语句来捕获并处理这些异常。
-
代码的可读性和可维护性：为了提高代码的可读性和可维护性，应该注意遵循一些良好的编程实践。例如，在编写代码时，应该使用有意义的变量名、避免过长的方法和过深的嵌套等。此外，在编写代码时，应该注意模块化设计，将程序划分成若干个独立的模块，每个模块负责实现一个特定的功能。
-
持续重构：在编写代码的过程中，应该不断地重构代码，以提高代码的质量。重构是指在不改变代码外部行为的情况下，改进代码的内部结构。通过重构，可以消除代码中的重复、简化复杂的逻辑、提高代码的可读性和可维护性等。
-
编写测试用例：为了确保代码的正确性，应该编写测试用例来对代码进行测试。测试用例可以帮助我们快速地发现代码中的错误，并及时修复它们。此外，测试用例还可以帮助我们验证重构后的代码是否仍然能够正确地工作。
-
代码审查：可以定期进行代码审查，邀请其他开发人员对代码进行审查。通过代码审查，可以发现代码中的问题，并及时修复它们。此外，代码审查还可以帮助我们学习其他开发人员的经验和技巧，从而提高自己的编程能力。
-
持续学习：作为一名开发人员，应该不断地学习新知识和技能，以便更好地应对各种挑战。可以阅读技术书籍、参加技术培训、参加技术交流会等方式来学习新知识和技能。
五、总结：
通过本阶段（10-16周）的学习，可以学到以下几点：
-
通过本阶段的学习，可以了解Java语言的基本语法和特性，以及如何使用Java语言来实现各种功能。
-
如何组织和管理数据：上述代码中包含了多个类和方法，用来存储和管理学生、课程、班级和选课信息。通过学习这段代码，可以了解如何使用ArrayList等数据结构来存储和管理数据，以及如何对数据进行增删改查操作。
-
如何处理用户输入：上述代码中包含了一个parseInput()方法，用来处理用户输入的数据。通过学习这段代码，可以了解如何使用Scanner类来读取用户输入，以及如何对用户输入的数据进行解析和处理。
-
如何进行错误处理：上述代码中包含了多处错误处理的代码，用来检查用户输入的数据是否正确，并输出相应的错误信息。通过学习这段代码，可以了解如何在代码中进行错误检查，并输出相应的错误信息。
对于需要进一步学习和研究的地方，包括：
-
更深入地学习Java语言：上述代码只展示了Java语言的基础知识，要想更好地掌握Java语言，还需要更深入地学习Java语言的高级特性和技巧。
-
学习更多的数据结构和算法：上述代码中只使用了ArrayList这一种数据结构，要想更好地存储和管理数据，还需要学习更多的数据结构和算法。
-
学习软件工程相关知识：上述代码只是一个简单的程序，要想编写更大型、更复杂的软件系统，还需要学习软件工程相关知识，包括需求分析、设计、编码、测试等方面。
对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议及意见：
1.希望能有更加充裕的时间来完成作业。
2.希望老师能提供更加详细周到的帮助。
3.希望作业的难度能够循序渐进，不要难度跨越过大。
4.希望老师能使用更加有趣的教学方式。