OOP第三次作业总结（222019班22201321）

一、前言

　　　　这次作业总结主要是总结分析训练集07~12，总共六次训练集，题量在可接受范围内，难度较大的主要是训练集10~12，这三次编写的都是课程成绩统计程序。

　　　　这六次训练集涉及的关于面向对象（Java）知识点主要有：类设计、继承、多态、接口、集合框架以及List、Set、Map接口的使用。

　　　　我感觉此次的难度较上一次又上升了一个梯度，尤其是在写训练集10课程成绩统计程序时，真的很难去理清其中的需求顺序，其中的排除异常情况数量比较多，程序很复杂，我未能在规定时间内通过所有的测试点，后来去请教了一下已经满分的同学，找到我的代码的缺陷，重构了一遍代码，但此时训练集10已经关闭，我无法验证我是否能过通过所有测试点，但应该是没有问题的。在接下来的训练集11和训练集12中是对课程成绩统计程序的扩展，我是在训练集10重构的代码的基础上扩展的，幸好这个代码是没有什么大问题的，所以训练集11和训练集12写起来没有训练集10那么困难，但也是花了比较大的精力。

二、设计与分析

　　　　接下来我主要对训练集08、训练集09以及训练集10~12中的课程成绩统计程序的提交源码进行分析。

训练集08：

题目需求：

（1）实现功能

　　本程序仅用于为学生所玩的游戏提供正确答案的功能，即根据学生得到的卡片种类与数量，给出排序前和排序后的卡片顺序，同时给出所有卡片的面积之和。

（2）输入输出规则

　　①输入规则

　　　　首先，在一行上输入一串数字（1~4，整数），其中，1 代表圆形卡片，2 代表矩形卡片，3 代表三角形卡片，4 代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如： 1 3 4 2 1 3 4 2 1 3 0 然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。

　　②输出规则

　　　　  如果图形数量非法（小于 0）或图形属性值非法（数值小于 0 以及三角形三边不能组成三角形），则输出“Wrong Format”。

　　　　  如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。

　　　　  输出内容如下：

　　　　　　 排序前的各图形类型及面积，格式为“图形名称 1:面积值 1 图形名称 2:面积值 2 …图形名称 n:面积值 n ”，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；　　　　　　 排序后的各图形类型及面积，格式同排序前的输出；

　　　　　　 所有图形的面积总和，格式为“Sum of area:总面积值”。

以下是我的代码：

  1 import java.util.ArrayList;
  2 import java.util.Collections;
  3 import java.util.List;
  4 import java.util.Scanner;
  5 public class Main {
  6     public static Scanner input = new Scanner(System.in);
  7     public static void main(String[] args) {
  8         CardUtil util=new CardUtil();
  9         util.init();
 10     }
 11 }
 12 class CardUtil {
 13     private ArrayList<Card> cardList=new ArrayList<>();
 14 
 15     public CardUtil() {
 16         cardList = new ArrayList<>();
 17     }
 18     CardUtil(ArrayList<Card> cardList){
 19         this.cardList=cardList;
 20     }
 21 
 22     public void init() {
 23         Scanner input = Main.input;
 24         ArrayList<Integer> list = new ArrayList<Integer>();
 25         int count = input.nextInt();
 26         while(count != 0){
 27             if(count < 0 || count > 4){
 28                 System.out.println("Wrong Format");
 29                 return;
 30             }
 31             list.add(count);
 32             count = input.nextInt();
 33         }
 34         for(int i=0;i<list.size();i++){
 35             switch (list.get(i)) {
 36                 case 1: {
 37                     double radius = input.nextDouble();
 38                     if (radius < 0) {
 39                         System.out.println("Wrong Format");
 40                         return;
 41                     }
 42                     cardList.add(new Circle(radius));
 43                     break;
 44                 }
 45                 case 2: {
 46                     double width = input.nextDouble();
 47                     double length = input.nextDouble();
 48                     if (width < 0 || length < 0) {
 49                         System.out.println("Wrong Format");
 50                         return;
 51                     }
 52                     cardList.add(new Rectangle(width, length));
 53                     break;
 54                 }
 55                 case 3: {
 56                     double side1 = input.nextDouble();
 57                     double side2 = input.nextDouble();
 58                     double side3 = input.nextDouble();
 59                     if (side1 < 0 || side2 < 0 || side3 < 0 || side1 + side2 <= side3 || side1 + side3 <= side2 || side2 + side3 <= side1) {
 60                         System.out.println("Wrong Format");
 61                         return;
 62                     }
 63                     cardList.add(new Triangle(side1,side2,side3));
 64                     break;
 65                 }
 66                 case 4: {
 67                     double top = input.nextDouble();
 68                     double bottom = input.nextDouble();
 69                     double height = input.nextDouble();
 70                     if (top < 0 || bottom < 0 || height < 0) {
 71                         System.out.println("Wrong Format");
 72                         return;
 73                     }
 74                     cardList.add(new Trapezoid(top, bottom, height));
 75                     break;
 76                 }
 77                 default: {
 78                     return;
 79                 }
 80             }
 81         }
 82         show();
 83         input.close();
 84     }
 85 
 86     public double getSumArea() {
 87         double sum = 0;
 88         for (Card shape : cardList) {
 89             sum += shape.getArea();
 90         }
 91         return sum;
 92     }
 93 
 94     public void show(){
 95         System.out.println("The original list:");
 96         ArrayList<Card> cards=new ArrayList<>();
 97         for(int i=0;i<cardList.size();i++){
 98             cardList.get(i).show();
 99         }
100         Collections.sort(cardList);
101         for(int i=0;i<cardList.size();i++){
102             cards.add(cardList.get(cardList.size()-i-1));
103         }
104         System.out.println("\nThe sorted list:");
105         for(int i=0;i<cards.size();i++){
106             cards.get(i).show();
107         }
108         System.out.println("\nSum of area:"+String.format("%.2f",this.getSumArea()));
109     }
110 }
111 abstract class Card implements Comparable<Card>{
112 
113     public abstract double getArea();
114     public abstract void show();
115     
116     @Override
117     public int compareTo(Card shape) {
118         double diff = this.getArea() - shape.getArea();
119         if (diff > 0) {
120             return 1;
121         } else if (diff < 0) {
122             return -1;
123         } else {
124             return 0;
125         }
126     }// 实现 Comparable 接口的 CompareTo() 方法，根据卡片面积大小进行比较
127 
128 }
129 class Circle extends Card{
130     private double radius;
131     Circle(){}
132     Circle(double radius){
133         this.radius=radius;
134     }
135     @Override
136     public double getArea(){
137         return Math.PI*this.radius*this.radius;
138     }
139     @Override
140     public void show(){
141         System.out.print("Circle:"+String.format("%.2f", getArea())+" ");
142     }
143 
144     public double getRadius() {
145         return radius;
146     }
147 
148     public void setRadius(double radius) {
149         this.radius = radius;
150     }
151 }
152 class Rectangle extends Card{
153     private double width;
154     private double length;
155     Rectangle(){}
156     Rectangle(double width,double length){
157         this.length=length;
158         this.width=width;
159     }
160     @Override
161     public double getArea(){
162         return this.length*this.width;
163     }
164     @Override
165     public void show(){
166         System.out.print("Rectangle:"+String.format("%.2f", getArea())+" ");
167     }
168 
169     public double getLength() {
170         return length;
171     }
172 
173     public void setLength(double length) {
174         this.length = length;
175     }
176 
177     public double getWidth() {
178         return width;
179     }
180 
181     public void setWidth(double width) {
182         this.width = width;
183     }
184 }
185 class Trapezoid extends Card {
186     private double top;
187     private double bottom;
188     private double height;
189     Trapezoid(){}
190     Trapezoid(double top,double bottom,double height){
191         this.bottom=bottom;
192         this.top=top;
193         this.height=height;
194     }
195     @Override
196     public double getArea(){
197         return (this.bottom+this.top)*this.height/2;
198     }
199     @Override
200     public void show(){
201         System.out.print("Trapezoid:"+String.format("%.2f", getArea())+" ");
202     }
203 
204     public double getTop() {
205         return top;
206     }
207 
208     public void setTop(double top) {
209         this.top = top;
210     }
211 
212     public double getBottom() {
213         return bottom;
214     }
215 
216     public void setBottom(double bottom) {
217         this.bottom = bottom;
218     }
219 
220     public double getHeight() {
221         return height;
222     }
223 
224     public void setHeight(double height) {
225         this.height = height;
226     }
227 }
228 class Triangle extends Card{
229     private double side1;
230     private double side2;
231     private double side3;
232     Triangle(){}
233     Triangle(double side1,double side2,double side3){
234         this.side1=side1;
235         this.side2=side2;
236         this.side3=side3;
237     }
238     @Override
239     public double getArea(){
240         double p=(this.side1+this.side2+this.side3)/2;
241         return Math.sqrt(p * (p - this.side1) * (p - this.side2) * (p - this.side3));
242     }
243     @Override
244     public void show(){
245         System.out.print("Triangle:"+String.format("%.2f", getArea())+" ");
246     }
247 
248     public double getSide1() {
249         return side1;
250     }
251 
252     public void setSide1(double side1) {
253         this.side1 = side1;
254     }
255 
256     public double getSide2() {
257         return side2;
258     }
259 
260     public void setSide2(double side2) {
261         this.side2 = side2;
262     }
263 
264     public double getSide3() {
265         return side3;
266     }
267 
268     public void setSide3(double side3) {
269         this.side3 = side3;
270     }
271 }

训练集08

以下是我的设计类图：

　　首先，我定义了一个CardUtil类，用于处理卡片的操作。该类包含一个cardList成员变量，用于存储卡片对象。

　　在CardUtil类的构造函数中，我初始化了cardList对象。

　　init()方法用于初始化卡片列表。在该方法中，通过输入获取用户输入的卡片信息，并根据输入的类型创建相应的卡片对象，然后将其添加到cardList中。

　　show()方法用于展示卡片列表。在该方法中，首先在控制台打印原始的卡片列表，然后对其进行排序，将排序后的列表存储在一个新的ArrayList对象中，并打印排序后的列表。最后，计算卡片列表中所有卡片的面积之和，并打印该值。

　　Card类是一个抽象类，定义了getArea()和show()两个抽象方法。这两个方法将在具体的卡片类中被实现。

　　Circle、Rectangle、Trapezoid和Triangle类分别是Card类的子类，它们实现了Card类中定义的抽象方法。这些具体的卡片类分别代表圆形、矩形、梯形和三角形。

　　Comparable接口的compareTo()方法被Card类实现，用于比较两个卡片的面积大小。通过实现该方法，可以在排序卡片列表时使用Collections.sort()方法进行排序。

　　最后在Main类中，创建了CardUtil对象util，并调用util的init()方法来开始处理卡片操作。

训练集09：

题目需求：

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

Java中共有53个关键字（自行百度）
从键盘输入一段源码，统计这段源码中出现的关键字的数量
注释中出现的关键字不用统计
字符串中出现的关键字不用统计
统计出的关键字及数量按照关键字升序进行排序输出
未输入源码则认为输入非法

以下是我的代码：

 1 import java.util.*;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         Scanner in = new Scanner(System.in);
 6         StringBuilder code = new StringBuilder();
 7         String line;
 8         while (!(line = in.nextLine()).equals("exit")) {
 9             line=line.replaceAll("=","a");
10             code.append(line).append("\n");
11         }
12         if(code.length()==0){
13             System.out.println("Wrong Format");
14             return;
15         }
16         String[] keywords = {"abstract", "assert", "boolean",
17                 "break", "byte", "case", "catch", "char", "class", "const",
18                 "continue", "default", "do", "double", "else", "enum",
19                 "extends", "for", "final", "finally", "float", "goto",
20                 "if", "implements", "import", "instanceof", "int",
21                 "interface", "long", "native", "new", "package", "private",
22                 "protected", "public", "return", "short", "static",
23                 "strictfp", "super", "switch", "synchronized", "this",
24                 "throw", "throws", "transient", "try", "void", "volatile",
25                 "while", "true", "false", "null"};
26 
27         Map<String, Integer> keywordCount = new TreeMap<>();//TreeMap内部自动排序
28         boolean inString = false;//字符串内
29         boolean inSingleLineComment = false;//行注释内
30         boolean inMultiLineComment = false;//块注释内
31         
32         for (int i = 0; i < code.length(); i++) {
33             char c = code.charAt(i);
34             if (inSingleLineComment) {
35                 if (c == '\n') {
36                     inSingleLineComment = false;
37                 }
38             } else if (inMultiLineComment) {
39                 if (c == '*' && i < code.length() - 1 && code.charAt(i + 1) == '/') {
40                     inMultiLineComment = false;
41                     i++;
42                 }
43             } else if (inString) {
44                 if (c == '"') {
45                     inString = false;
46                 }
47             }
48             else {
49                 if (c == '"') {
50                     inString = true;
51                 } else if (c == '/' && i < code.length() - 1) {
52                     char next = code.charAt(i + 1);
53                     if (next == '/') {
54                         inSingleLineComment = true;
55                         i++;
56                     } else if (next == '*') {
57                         inMultiLineComment = true;
58                         i++;
59                     }
60                 } else if (Character.isJavaIdentifierStart(c)) {//检测i字节上的位置是否为关键词的第一个
61                     StringBuilder builder = new StringBuilder();
62                     builder.append(c);
63                     int j = i + 1;
64                     while (j < code.length() && Character.isJavaIdentifierPart(code.charAt(j))) {//检测j字节上的位置是否为关键词的后几位
65                         builder.append(code.charAt(j));
66                         j++;
67                     }
68                     String word = builder.toString();
69                    
70                 
71                     if (Arrays.asList(keywords).contains(word)) {
72                         keywordCount.put(word, keywordCount.getOrDefault(word, 0) + 1);
73                     }
74                     i = j - 1;
75                 }
76             }
77         }
78         if (keywordCount.isEmpty()) {
79             System.out.println();
80         } else {
81             Set<Map.Entry<String, Integer>> sets=keywordCount.entrySet();//遍历
82             for (Map.Entry<String, Integer> entry : sets) {
83                 System.out.println(entry.getValue() + "\t" + entry.getKey());
84             }
85         }
86     }
87 }

训练集09

　　使用StringBuilder对象code来存储用户输入的代码。通过使用循环和in.nextLine()方法读取每一行代码，并将其追加到code中。在添加代码行之前，将所有的"="替换为字母"a"，以避免干扰关键词统计的过程。如果code的长度为0，说明用户没有输入任何代码，直接打印错误信息"Wrong Format"并返回。

　　创建一个TreeMap对象keywordCount，用于统计关键词的出现次数。因为TreeMap会自动按照关键词的字母顺序进行排序。

　　接着，使用一个for循环遍历code中的每一个字符。我们根据不同的情况处理字符：

　　　　 - 如果在单行注释内，检查字符是否为换行符，如果是，则结束单行注释。

　　　　- 如果在块注释内，检查字符是否为"*/"的结束标记，如果是，则结束块注释。

　　　　 - 如果在字符串内，检查字符是否为双引号的结束标记，如果是，则结束字符串。

　　　　- 如果不在注释和字符串内，检查字符是否为双引号的起始标记，如果是，则开始字符串。

　　　　- 如果字符为斜杠，并且紧跟着"//"，则开始单行注释。 - 如果字符为斜杠，并且紧跟着"/*"，则开始块注释。

　　　　- 如果字符是Java关键词的起始字符，则构建一个StringBuilder对象builder，并从当前位置开始，逐个添加字符，直到构建出完整的关键词。

　　如果关键词在keywords数组中，则在keywordCount中增加该关键词的计数。

训练集10：

课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

以下是我的得分为71分的代码：

  1 import java.util.ArrayList;
  2 import java.util.Collections;
  3 import java.text.Collator;
  4 import java.util.Comparator;
  5 import java.util.Scanner;
  6 public class Main {
  7     public static void main(String[] args) {
  8         Scanner in=new Scanner(System.in);
  9         String info=in.nextLine();
 10         Handle handle=new Handle();
 11         while(!info.equals("end")){
 12             handle.Handle(info);
 13             info=in.nextLine();
 14         }
 15         handle.showStudents();
 16         handle.showCourse();
 17         handle.showClasses();
 18     }
 19 }
 20 class Handle {
 21     ArrayList<Course> listCourse = new ArrayList<>();
 22     ArrayList<Student> listStudent = new ArrayList<>();
 23     ArrayList<SelectCourse> listSelectCourse = new ArrayList<>();
 24     ArrayList<Class> listCls = new ArrayList<>();
 25 
 26     public Handle() {
 27     }
 28 
 29     public void Handle(String s) {
 30         int i = InputMatching.matchingInput(s);
 31         String[] items = s.split(" ");
 32         switch (i) {
 33             case 0:
 34                 System.out.println("wrong format");
 35                 return;
 36             case 1:
 37                 dealCourse(items);
 38                 return;
 39             case 2:
 40                 dealScore(items);
 41         }
 42     }
 43     Student getStudent(String stuId) {
 44         for (int i = 0; i < listStudent.size(); i++) {
 45             if (listStudent.get(i).getId().equals(stuId)) {
 46                 return listStudent.get(i);
 47             }
 48         }
 49         return null;
 50     }
 51 
 52     Course getCourse(String courseName) {
 53         for (int i = 0; i < listCourse.size(); i++) {
 54             if (listCourse.get(i).getName().equals(courseName)) {
 55                 return listCourse.get(i);
 56             }
 57         }
 58         return null;
 59     }
 60 
 61     Class getCls(String clsId) {
 62         for (int i = 0; i < listCls.size(); i++) {
 63             if (listCls.get(i).getId().equals(clsId)) {
 64                 return listCls.get(i);
 65             }
 66         }
 67         return null;
 68     }
 69 
 70 
 71     public ArrayList<SelectCourse> getStudentSelects(String stuId) {
 72         ArrayList<SelectCourse> stuSelects = new ArrayList<>();
 73         for (SelectCourse cs : listSelectCourse) {
 74             if (stuId.equals(cs.student.getId())) {
 75                 stuSelects.add(cs);
 76             }
 77         }
 78         return stuSelects;
 79     }
 80 
 81 
 82     public ArrayList<SelectCourse> getCourseSelects(String courseName) {
 83         ArrayList<SelectCourse> courseSelects = new ArrayList<>();
 84         for (SelectCourse cs : listSelectCourse) {
 85             if (courseName.equals(cs.course.getName())) {
 86                 courseSelects.add(cs);
 87             }
 88         }
 89         return courseSelects;
 90     }
 91 
 92     public ArrayList<SelectCourse> getClassSelects(String className) {
 93         Class cls=getCls(className);
 94         ArrayList<SelectCourse> clsSelects = new ArrayList<>();
 95         for (SelectCourse cs : listSelectCourse) {
 96             if (className.equals(cls.getId())){
 97                 clsSelects.add(cs);
 98             }
 99         }
100         return clsSelects;
101     }
102     public int getAvgTotalScore(ArrayList<SelectCourse> listSelectCourse) {
103         int sum = 0;
104         for (SelectCourse cs : listSelectCourse) {
105             sum += cs.score.getTotalScore();
106         }
107         return sum / listSelectCourse.size();
108     }
109     public int getAvgUsualScore(ArrayList<SelectCourse> courseSelects) {
110         int sum = 0;
111         for (SelectCourse cs : courseSelects) {
112             sum += ((ExamScore)cs.score).getUsualScore();
113         }
114         return sum / courseSelects.size();
115     }
116     public int getAvgFinalScore(ArrayList<SelectCourse> courseSelects) {
117         int sum = 0;
118         for (SelectCourse cs : courseSelects) {
119             sum += cs.score.getFinalScore();
120         }
121         return sum / courseSelects.size();
122     }
123 
124     private void dealCourse(String[] items) {
125         String courseName = items[0];
126         String courseType = items[1];
127         String checkType = items[2];
128         Course course = new Course(courseName, courseType, checkType);
129         if (!checkCourse(course))
130             return;
131         if (getCourse(courseName) == null) {
132             course = new Course(courseName, courseType, checkType);
133             listCourse.add(course);
134         }
135     }
136     private void dealScore(String[] items) {
137         String stuId = items[0];
138         String stuName = items[1];
139         String courseName = items[2];
140         String clsId = stuId.substring(0, 6);
141         Class cls;
142         Student stu;
143         cls = getCls(clsId);
144         if (cls == null) {
145             cls = new Class(clsId);
146             listCls.add(cls);
147         }
148         stu = getStudent(stuId);
149         if (stu == null) {
150             stu = new Student(stuName, stuId);
151             listStudent.add(stu);
152         }
153         Course course = getCourse(courseName);
154         if (course == null) {
155             System.out.println(courseName + " does not exist");
156             return;
157         }
158         if (!checkMethod(items, course))
159             return;
160         Score score;
161         if (items.length == 4) {
162             int finalScore = Integer.parseInt(items[3]);
163             score = new AssessmentScore(finalScore);
164         } else {
165             int usualScore = Integer.parseInt(items[3]);
166             int finalScore = Integer.parseInt(items[4]);
167             score = new ExamScore(usualScore, finalScore);
168         }
169         if (existChooseCourse(stu, course))
170             return;
171         SelectCourse selectCourse = new SelectCourse(course, stu, score);
172         listSelectCourse.add(selectCourse);
173     }
174 
175     boolean existChooseCourse(Student stu, Course course) {
176         for (int i = 0; i < listSelectCourse.size(); i++) {
177             if (listSelectCourse.get(i).getCourse().getName().equals(course.getName())) {
178                 if (listSelectCourse.get(i).getStudent().getName().equals(stu.getName())) {
179                     return true;
180                 }
181             }
182         }
183         return false;
184     }
185 
186     private boolean checkMethod(String[] items, Course course) {
187         String courseType = course.getMethod();
188         if (courseType.equals("考试") && items.length == 5) {
189             return true;
190         }
191         if (courseType.equals("考察") && items.length == 4) {
192             return true;
193         }
194         System.out.println(items[0] + " " + items[1] + " : access mode mismatch");
195         return false;
196     }
197 
198     boolean checkCourse(Course course) {
199         if (course.getType().equals("必修")&&course.getMethod().equals("考试"))
200             return true;
201         if (course.getType().equals("选修") && (course.getMethod().equals("考试")||course.getMethod().equals("考察")))
202             return true;
203         System.out.println(course.getName() + " : course type & access mode mismatch");
204         return false;
205     }
206 
207 
208     public void showCourse() {
209         Collections.sort(listCourse);
210         for (int i = 0; i < listCourse.size(); i++) {
211             Course course = listCourse.get(i);
212             ArrayList<SelectCourse> courseSelects = getCourseSelects(course.getName());
213             if (courseSelects.size() == 0) {
214                 System.out.println(course.getName() + " has no grades yet");
215             } else {
216                 if (course.getMethod().equals("考试")) {
217                     System.out.println(course.getName() + " " + getAvgUsualScore(courseSelects) + " " + getAvgFinalScore(courseSelects) + " " + getAvgTotalScore(courseSelects));
218                 } else {
219                     System.out.println(course.getName() + " " + getAvgFinalScore(courseSelects) + " " + getAvgTotalScore(courseSelects));
220                 }
221             }
222         }
223     }
224 
225     public void showStudents() {
226         Collections.sort(listStudent);
227         for (int i = 0; i < listStudent.size(); i++) {
228             Student stu = listStudent.get(i);
229             ArrayList<SelectCourse> stuCourseSelects = getStudentSelects(stu.getId());
230             if (stuCourseSelects.size() != 0) {
231                 System.out.println(stu.getId() + " " + stu.getName() + " " + getAvgTotalScore(stuCourseSelects));
232             } else {
233                 System.out.println(stu.getId() + " " + stu.getName() + " did not take any exams");
234             }
235         }
236     }
237 
238     public void showClasses() {
239         Collections.sort(listCls);
240         for (int i = 0; i < listCls.size(); i++) {
241             Student stu = listStudent.get(i);
242             Class cls = listCls.get(i);
243             //ArrayList stuCls = getStudentSelects(stu.getId().substring(0, 6));
244             ArrayList<SelectCourse> clsCourseSelects = getClassSelects(stu.getId().substring(0,6));
245             if (clsCourseSelects.size() != 0) {
246                 System.out.println(cls.getId() + " " + getAvgTotalScore(clsCourseSelects));
247             } else {
248                 System.out.println(cls.getId() + " has no grades yet");
249             }
250         }
251     }
252 }
253 class SelectCourse {
254     Student student;
255 
256     Course course;
257     Score score;
258 
259 
260     public SelectCourse(Course course, Student student, Score score) {
261         this.student = student;
262         this.course = course;
263         this.score = score;
264     }
265 
266     public Student getStudent() {
267         return student;
268     }
269 
270     public void setStudent(Student student) {
271         this.student = student;
272     }
273 
274     public Course getCourse() {
275         return course;
276     }
277 
278     public void setCourse(Course course) {
279         this.course = course;
280     }
281 
282     public Score getGrade() {
283         return score;
284     }
285 
286     public void setGrade(Score score) {
287         this.score = score;
288     }
289 }
290 class Student implements Comparable<Student> {
291     String name;
292     String Id;
293     Class cls;
294 
295     public Student(String name, String id) {
296         this.name = name;
297         Id = id;
298     }
299     public String getName() {
300         return name;
301     }
302 
303     public void setName(String name) {
304         this.name = name;
305     }
306 
307     public String getId() {
308         return Id;
309     }
310 
311     public void setId(String id) {
312         Id = id;
313     }
314 
315     public Class getCls() {
316         return cls;
317     }
318 
319     public void setCls(Class cls) {
320         this.cls = cls;
321     }
322 
323     public int compareTo(Student o) {
324         return getId().compareTo(o.getId());
325     }
326 }
327 
328 class Class implements Comparable<Class> {
329     String cls;
330     String id;
331     ArrayList<Student> listStudent = new ArrayList<>();
332     public Class(String id) {
333         this.id=id;
334     }
335     public String getId() {
336         return id;
337     }
338     void addStudent(Student stu) {
339         listStudent.add(stu);
340     }
341     public String getCls() {
342         return cls;
343     }
344     public void setCls(String cls) {
345         this.cls = cls;
346     }
347 
348     public void setId(String id) {
349         this.id = id;
350     }
351 
352     @Override
353     public int compareTo(Class o) {
354         return getCls().compareTo(o.getCls());
355     }
356 }
357 
358 
359 class InputMatching {
360     static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
361     static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
362     static String scoreMatching = "([1-9]?[0-9]|100)";
363     static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
364     static String courseTypeMatching = "(选修|必修)";
365     static String checkcourseTypeMatching = "(考试|考察)";
366     //cousrInput用于定义课程信息模式（正则表达式）
367     static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
368     //scoreInput用于定义成绩信息模式（正则表达式）
369     static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
370             scoreMatching + "(scoreMatching)?";
371     public static int matchingInput(String s) {
372         if (matchingCourse(s)) {
373             return 1;
374         }
375         if (matchingScore(s)) {
376             return 2;
377         }
378         return 0;
379     }
380     private static boolean matchingCourse(String s) {
381         return s.matches(courseInput);
382     }
383 
384     private static boolean matchingScore(String s) {
385         //System.out.println(match);
386         return s.matches(scoreInput);
387     }
388 }
389 class Course implements Comparable<Course>{
390     String name;
391     String type;
392     String method;
393     public Course(String name, String type, String method) {
394         this.name = name;
395         this.type = type;
396         this.method = method;
397     }
398 
399     public String getName() {
400         return name;
401     }
402 
403     public void setName(String name) {
404         this.name = name;
405     }
406     public String getType() {
407         return type;
408     }
409 
410     public void setType(String type) {
411         this.type = type;
412     }
413 
414     public String getMethod() {
415         return method;
416     }
417 
418     public void setMethod(String method) {
419         this.method = method;
420     }
421 
422     public int compareTo(Course o) {
423         Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
424         return compare.compare(name, o.getName());
425     }
426 }
427 abstract  class Score {
428     int finalScore;
429     int totalScore;
430     public Score(int finalScore, int totalScore) {
431         this.finalScore = finalScore;
432         this.totalScore = totalScore;
433     }
434 
435     public Score(int finalScore){
436         this.finalScore=finalScore;
437     }
438     public int getFinalScore() {
439         return finalScore;
440     }
441 
442     public void setFinalScore(int finalScore) {
443         this.finalScore = finalScore;
444     }
445 
446     public int getTotalScore() {
447         return totalScore;
448     }
449 
450     public void setTotalScore(int totalScore) {
451         this.totalScore = totalScore;
452     }
453 }
454 class AssessmentScore extends Score //考察成绩
455 {
456     public AssessmentScore(int finalScore) {
457         super(finalScore);
458         this.totalScore = finalScore;
459     }
460 }
461 class ExamScore extends Score//考试成绩
462 {
463 
464     private int usualScore;
465 
466     public int getUsualScore() {
467         return usualScore;
468     }
469 
470     public void setUsualScore(int usualScore) {
471         this.usualScore = usualScore;
472     }
473 
474     public ExamScore(int usualScore, int finalScore) {
475         super(finalScore);
476         this.usualScore=usualScore;
477         this.totalScore = (int) (usualScore * 0.3 + finalScore * 0.7);
478     }
479 }

课程成绩统计程序-1

以下是我的设计类图：

为了方便对学生、课程和成绩进行管理，选择使用ArrayList作为存储数据的数据结构。通过ArrayList，可以方便地添加、删除和查找数据。

为了方便用户输入命令并进行相应的操作，设计了InputMatching类。这个类通过正则表达式进行输入的匹配，判断用户输入的命令类型，并返回相应的标识码。

Handle类接收用户输入的命令，根据命令类型调用相应的方法进行处理。

　　先通过InputMatching类的matchingInput方法判断命令的类型，并根据类型调用dealCourse方法或dealScore方法进行处理。

　　dealCourse方法：这个方法用于处理添加课程的命令。它接收一个包含课程名称、类型和考核方式的字符串数组，首先调用checkCourse方法检查课程的合法性，然后根据课程名称查找是否已存在该课程，如果不存在则创建新的Course对象并添加到listCourse列表中。

　　dealScore方法：这个方法用于处理添加学生成绩的命令。它接收一个包含学生信息、课程名称和成绩的字符串数组，首先通过相关方法创建或获取学生、班级和课程对象，然后根据课程的考核方式和输入的成绩进行校验，最后创建SelectCourse对象并添加到listSelectCourse列表中。

　　getStudent、getCourse和getCls方法：这些方法用于根据学生ID、课程名称和班级ID获取对应的学生、课程和班级对象。　　

　　getStudentSelects、getCourseSelects和getClassSelects方法：这些方法用于获取指定学生、课程和班级的选课记录列表。

　　getAvgTotalScore、getAvgUsualScore和getAvgFinalScore方法：这些方法用于计算选课记录列表中成绩的平均值，分别对应总成绩、平时成绩和期末成绩。

　　checkMethod和checkCourse方法：这些方法用于检查课程的考核方式和类型是否与成绩输入的格式相符合。　　

　　showStudents、showCourse和showClasses方法：这些方法用于显示学生、课程和班级的成绩情况。它们通过调用其他方法获取相应的选课记录列表，并计算平均成绩后进行输出。

不过，照这样写，还是有八个测试点没过，稍后会在改进建议中写到如何改进。

训练集11：

课程成绩统计程序-2：

课程成绩统计程序-2在第一次的基础上增加了实验课，以下为本次新增的内容：

　　某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。

　　考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

　　考察的总成绩直接等于期末成绩

　　实验的总成绩等于课程每次实验成绩的平均分

　　必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。

　　课程性质输入项：必修、选修、实验

　　考核方式输入选项：考试、考察、实验

　　实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩

　　实验次数至少4次，不超过9次

　　实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩

　　实验课成绩格式：课程名称+英文空格+总成绩平均分

以下是我的代码：

  1 import java.util.ArrayList;
  2 import java.util.Collections;
  3 import java.text.Collator;
  4 import java.util.Comparator;
  5 import java.util.Scanner;
  6 public class Main {
  7     public static void main(String[] args) {
  8         Scanner in=new Scanner(System.in);
  9         String info=in.nextLine();
 10         Handle handle=new Handle();
 11         while(!info.equals("end")){
 12             handle.Handle(info);
 13             info=in.nextLine();
 14         }
 15         handle.showStudents();
 16         handle.showCourse();
 17         handle.showClasses();
 18     }
 19 }
 20 class Handle {
 21     ArrayList<Course> listCourse = new ArrayList<>();
 22     ArrayList<Student> listStudent = new ArrayList<>();
 23     ArrayList<SelectCourse> listSelectCourse = new ArrayList<>();
 24     ArrayList<Class> listCls = new ArrayList<>();
 25 
 26     public Handle() {
 27     }
 28 
 29     public void Handle(String s) {
 30         InputMatching im=new InputMatching();
 31         int i = im.matchingInput(s);
 32         String[] items = s.split(" ");
 33         switch (i){
 34             case 0:
 35                 System.out.println("wrong format");
 36                 break;
 37             case 1:
 38                 dealCourse(items);
 39                 break;
 40             case 2:
 41                 dealScore(items);
 42                 break;
 43         }
 44     }
 45     Student getStudent(String stuId) {
 46         for (int i = 0; i < listStudent.size(); i++) {
 47             if (listStudent.get(i).getId().equals(stuId)) {
 48                 return listStudent.get(i);
 49             }
 50         }
 51         return null;
 52     }
 53 
 54     Course getCourse(String courseName) {
 55         for (int i = 0; i < listCourse.size(); i++) {
 56             if (listCourse.get(i).getName().equals(courseName)) {
 57                 return listCourse.get(i);
 58             }
 59         }
 60         return null;
 61     }
 62 
 63     Class getCls(String clsId) {
 64         for (int i = 0; i < listCls.size(); i++) {
 65             if (listCls.get(i).getId().equals(clsId)) {
 66                 return listCls.get(i);
 67             }
 68         }
 69         return null;
 70     }
 71 
 72 
 73     public ArrayList<SelectCourse> getStudentSelects(String stuId) {
 74         ArrayList<SelectCourse> stuSelects = new ArrayList<>();
 75         for (SelectCourse sc : listSelectCourse) {
 76             if (stuId.equals(sc.student.getId())) {
 77                 stuSelects.add(sc);
 78             }
 79         }
 80         return stuSelects;
 81     }
 82 
 83     public ArrayList<SelectCourse> getCourseSelects(String courseName) {
 84         ArrayList<SelectCourse> courseSelects = new ArrayList<>();
 85         for (SelectCourse sc : listSelectCourse) {
 86             if (courseName.equals(sc.course.getName())) {
 87                 courseSelects.add(sc);
 88             }
 89         }
 90         return courseSelects;
 91     }
 92 
 93     public ArrayList<SelectCourse> getClassSelects(String classId) {
 94         ArrayList<SelectCourse> clsSelects = new ArrayList<>();
 95         for (SelectCourse sc : listSelectCourse) {
 96             if (classId.equals(sc.student.cls.getId())){
 97                 clsSelects.add(sc);
 98             }
 99         }
100         return clsSelects;
101     }
102     public int getAvgTotalScore(ArrayList<SelectCourse> listSelectCourse) {
103         int sum = 0;
104         for (SelectCourse sc : listSelectCourse) {
105             sum += sc.score.getTotalScore();
106         }
107         return sum / listSelectCourse.size();
108     }
109     public int getAvgUsualScore(ArrayList<SelectCourse> courseSelects) {
110         int sum = 0;
111         for (SelectCourse sc : courseSelects) {
112             sum += ((ExamScore)sc.score).getUsualScore();
113         }
114         return sum / courseSelects.size();
115     }
116     public int getAvgFinalScore(ArrayList<SelectCourse> courseSelects) {
117         int sum = 0;
118         for (SelectCourse sc : courseSelects) {
119             sum += sc.score.getFinalScore();
120         }
121         return sum / courseSelects.size();
122     }
123 
124     private void dealCourse(String[] items) {
125         String courseName = items[0];
126         String courseType = items[1];
127         String checkType = items[2];
128         Course course = new Course(courseName, courseType, checkType);
129         if (!checkCourse(course))
130             return;
131         if (getCourse(courseName) == null) {
132             listCourse.add(course);
133         }
134     }
135     private void dealScore(String[] items) {
136         String stuId = items[0];
137         String stuName = items[1];
138         String courseName = items[2];
139         String clsId = stuId.substring(0, 6);
140         Class cls;
141         Student stu;
142         cls = getCls(clsId);
143         if (cls == null) {
144             cls = new Class(clsId);
145             listCls.add(cls);
146         }
147         stu = getStudent(stuId);
148         if (stu == null) {
149             stu = new Student(stuName, stuId);
150             listStudent.add(stu);
151             cls.addStudent(stu);
152         }
153         stu.setCls(cls);
154         Course course = getCourse(courseName);
155         if (course == null) {
156             System.out.println(courseName + " does not exist");
157             return;
158         }
159         if (!checkMethod(items, course))
160             return;
161         Score score;
162         if (items.length == 4) {
163             int finalScore = Integer.parseInt(items[3]);
164             score = new AssessmentScore(finalScore);
165         } else if(items.length==5) {
166             int usualScore = Integer.parseInt(items[3]);
167             int finalScore = Integer.parseInt(items[4]);
168             score = new ExamScore(usualScore, finalScore);
169         }
170         else {
171             int finalScore=0;
172             for(int i=4;i<items.length;i++){
173                 finalScore+=Integer.parseInt(items[i]);
174             }
175             finalScore=finalScore/Integer.parseInt(items[3]);
176             score=new AssessmentScore(finalScore);
177         }
178         if (existChooseCourse(stu, course))
179             return;
180         SelectCourse selectCourse = new SelectCourse(course, stu, score);
181         listSelectCourse.add(selectCourse);
182     }
183 
184     boolean existChooseCourse(Student stu, Course course) {
185         for (int i = 0; i < listSelectCourse.size(); i++) {
186             if (listSelectCourse.get(i).getCourse().getName().equals(course.getName())) {
187                 if (listSelectCourse.get(i).getStudent().getName().equals(stu.getName())) {
188                     return true;
189                 }
190             }
191         }
192         return false;
193     }
194 
195     private boolean checkMethod(String[] items, Course course) {
196         String courseType = course.getMethod();
197         if (courseType.equals("考试") && items.length == 5) {
198             return true;
199         }
200         if (courseType.equals("考察") && items.length == 4) {
201             return true;
202         }
203         if(courseType.equals("实验")&&items.length==(4+Integer.parseInt(items[3]))){
204             return true;
205         }
206         System.out.println(items[0] + " " + items[1] + " : access mode mismatch");
207         return false;
208     }
209 
210     boolean checkCourse(Course course) {
211         if (course.getType().equals("必修")&&course.getMethod().equals("考试"))
212             return true;
213         if (course.getType().equals("选修") && (course.getMethod().equals("考试")||course.getMethod().equals("考察")))
214             return true;
215         if (course.getType().equals("实验")&&course.getMethod().equals("实验"))
216             return true;
217         System.out.println(course.getName() + " : course type & access mode mismatch");
218         return false;
219     }
220 
221 
222     public void showCourse() {
223         Collections.sort(listCourse);
224         for (int i = 0; i < listCourse.size(); i++) {
225             Course course = listCourse.get(i);
226             ArrayList<SelectCourse> courseSelects = getCourseSelects(course.getName());
227             if (courseSelects.size() == 0) {
228                 System.out.println(course.getName() + " has no grades yet");
229             } else {
230                 if (course.getMethod().equals("考试")) {
231                     System.out.println(course.getName() + " " + getAvgUsualScore(courseSelects) + " " + getAvgFinalScore(courseSelects) + " " + getAvgTotalScore(courseSelects));
232                 } else if(course.getMethod().equals("考察")){
233                     System.out.println(course.getName() + " " + getAvgFinalScore(courseSelects) + " " + getAvgTotalScore(courseSelects));
234                 }
235                 else {
236                     System.out.println(course.getName()+" "+getAvgTotalScore(courseSelects));
237                 }
238             }
239         }
240     }
241 
242     public void showStudents() {
243         Collections.sort(listStudent);
244         for (int i = 0; i < listStudent.size(); i++) {
245             Student stu = listStudent.get(i);
246             ArrayList<SelectCourse> stuCourseSelects = getStudentSelects(stu.getId());
247             if (stuCourseSelects.size() != 0) {
248                 System.out.println(stu.getId() + " " + stu.getName() + " " + getAvgTotalScore(stuCourseSelects));
249             } else {
250                 System.out.println(stu.getId() + " " + stu.getName() + " did not take any exams");
251             }
252         }
253     }
254 
255     public void showClasses() {
256         Collections.sort(listCls);
257         for (int i = 0; i < listCls.size(); i++) {
258             Class cls = listCls.get(i);
259             ArrayList<SelectCourse> clsCourseSelects = getClassSelects(cls.getId());
260             if (clsCourseSelects.size() != 0) {
261                 System.out.println(cls.getId() + " " + getAvgTotalScore(clsCourseSelects));
262             } else {
263                 System.out.println(cls.getId() + " has no grades yet");
264             }
265         }
266     }
267 }
268 class InputMatching {
269     InputMatching(){}
270     static String stuNumMatching = "\\d{8}";//8个0-9的数字
271     static String stuNameMatching = "[^ \\t]{1,10}";//1到10个非空格（TAB）字符
272     static String scoreMatching = "([1-9]?[0-9]|100)";
273     static String courseNameMatching = "[^ \\t]{1,10}";//1到10个非空格（TAB）字符
274     static String courseTypeMatching = "(选修|必修|实验)";
275     static String checkCourseTypeMatching = "(考试|考察|实验)";
276     //courseInput用于定义课程信息模式（正则表达式）
277     static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
278     //scoreInput用于定义成绩信息模式（正则表达式）
279     static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
280             scoreMatching + "(\\s([1-9]?[0-9]|100))?" ;
281     //experimentInput用于定义实验信息模式（正则表达式）
282     static String experimentInput=stuNumMatching+" "+stuNameMatching+" "+courseNameMatching+" "
283             +"[4-9]"+"(\\s([1-9]?[0-9]|100)){1,10}";//
284     public static int matchingInput(String s) {
285         if (matchingCourse(s)) {
286             return 1;
287         }
288         if (matchingScore(s)||matchingExperiment(s)) {
289             return 2;
290         }
291         return 0;
292     }
293     private static boolean matchingCourse(String s) {
294         return s.matches(courseInput);
295     }
296     private static boolean matchingExperiment(String s){
297         return s.matches(experimentInput);
298     }
299     private static boolean matchingScore(String s) {
300         return s.matches(scoreInput);
301     }
302 }
303 
304 
305 class SelectCourse {
306     Student student;
307     Course course;
308     Score score;
309 
310 
311     public SelectCourse(Course course, Student student, Score score) {
312         this.student = student;
313         this.course = course;
314         this.score = score;
315     }
316 
317     public Student getStudent() {
318         return student;
319     }
320 
321     public void setStudent(Student student) {
322         this.student = student;
323     }
324 
325     public Course getCourse() {
326         return course;
327     }
328 
329     public void setCourse(Course course) {
330         this.course = course;
331     }
332 
333     public Score getGrade() {
334         return score;
335     }
336 
337     public void setGrade(Score score) {
338         this.score = score;
339     }
340 }
341 class Student implements Comparable<Student> {
342     String name;
343     String Id;
344     Class cls;
345 
346     public Student(String name, String id) {
347         this.name = name;
348         Id = id;
349     }
350     public String getName() {
351         return name;
352     }
353 
354     public void setName(String name) {
355         this.name = name;
356     }
357 
358     public String getId() {
359         return Id;
360     }
361 
362     public void setId(String id) {
363         Id = id;
364     }
365 
366     public Class getCls() {
367         return cls;
368     }
369 
370     public void setCls(Class cls) {
371         this.cls = cls;
372     }
373 
374     public int compareTo(Student o) {
375         return getId().compareTo(o.getId());
376     }
377 }
378 class Class implements Comparable<Class> {
379     String id;
380     ArrayList<Student> listStudent = new ArrayList<>();
381     public Class(String id) {
382         this.id=id;
383     }
384     public String getId() {
385         return id;
386     }
387     void addStudent(Student stu) {
388         listStudent.add(stu);
389     }
390 
391     @Override
392     public int compareTo(Class o) {
393         return getId().compareTo(o.getId());
394     }
395 }
396 class Course implements Comparable<Course>{
397     String name;
398     String type;
399     String method;
400     public Course(String name, String type, String method) {
401         this.name = name;
402         this.type = type;
403         this.method = method;
404     }
405 
406     public String getName() {
407         return name;
408     }
409 
410     public void setName(String name) {
411         this.name = name;
412     }
413     public String getType() {
414         return type;
415     }
416 
417     public void setType(String type) {
418         this.type = type;
419     }
420 
421     public String getMethod() {
422         return method;
423     }
424 
425     public void setMethod(String method) {
426         this.method = method;
427     }
428 
429     public int compareTo(Course o) {
430         Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
431         return compare.compare(name, o.getName());
432     }
433 }
434 abstract  class Score {
435     int finalScore;
436     int totalScore;
437     public Score(int finalScore, int totalScore) {
438         this.finalScore = finalScore;
439         this.totalScore = totalScore;
440     }
441 
442     public Score(int finalScore){
443         this.finalScore=finalScore;
444     }
445     public int getFinalScore() {
446         return finalScore;
447     }
448 
449     public void setFinalScore(int finalScore) {
450         this.finalScore = finalScore;
451     }
452 
453     public int getTotalScore() {
454         return totalScore;
455     }
456 
457     public void setTotalScore(int totalScore) {
458         this.totalScore = totalScore;
459     }
460 }
461 class AssessmentScore extends Score {//考察成绩
462     public AssessmentScore(int finalScore) {
463         super(finalScore);
464         this.totalScore = finalScore;
465     }
466 }
467 class ExamScore extends Score{//考试成绩
468     private int usualScore;
469 
470     public int getUsualScore() {
471         return usualScore;
472     }
473 
474     public void setUsualScore(int usualScore) {
475         this.usualScore = usualScore;
476     }
477 
478     public ExamScore(int usualScore, int finalScore) {
479         super(finalScore);
480         this.usualScore=usualScore;
481         this.totalScore = (int) (usualScore * 0.3 + finalScore * 0.7);
482     }
483 }

课程成绩统计程序-2

以下是我的设计类图：

课程成绩统计程序-2只是在程序-1的基础添加了一门实验课，所以只需要在dealScore方法里面添加代码如下：

else {
　　int finalScore=0;
　　for(int i=4;i<items.length;i++){
　　finalScore+=Integer.parseInt(items[i]);
　　}
　　finalScore=finalScore/Integer.parseInt(items[3]);
　　score=new AssessmentScore(finalScore);
}

另外，需要添加修改checkMethod方法、checkCourse方法以及一些输入匹配的字符串。

训练集12：

课程成绩统计程序-3：

课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式。

要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

以下内容为本次新增的内容：

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

实验的总成绩等于课程每次实验成绩乘以权重后累加而得。

课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）

课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝

为避免四舍五入误差，计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。

学生总成绩/整个班/课程平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

单门课程成绩按课程名称的字符顺序输出

课程成绩输出格式：课程名称+英文空格+总成绩平均分

如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"

如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"

以下是我的代码：

  1 import java.util.ArrayList;
  2 import java.util.Collections;
  3 import java.text.Collator;
  4 import java.util.Comparator;
  5 import java.util.Scanner;
  6 public class Main {
  7     public static void main(String[] args) {
  8         Scanner in=new Scanner(System.in);
  9         String info=in.nextLine();
 10         Handle handle=new Handle();
 11         while(!info.equals("end")){
 12             handle.Handle(info);
 13             info=in.nextLine();
 14         }
 15         handle.showStudents();
 16         handle.showCourse();
 17         handle.showClasses();
 18     }
 19 }
 20 class Handle {
 21     ArrayList<Course> listCourse = new ArrayList<>();
 22     ArrayList<Student> listStudent = new ArrayList<>();
 23     ArrayList<SelectCourse> listSelectCourse = new ArrayList<>();
 24     ArrayList<Class> listCls = new ArrayList<>();
 25 
 26     public Handle() {
 27     }
 28 
 29     public void Handle(String s) {
 30         InputMatching im=new InputMatching();
 31         int i = im.matchingInput(s);
 32         String[] items = s.split(" ");
 33         switch (i){
 34             case 0:
 35                 System.out.println("wrong format");
 36                 break;
 37             case 1:
 38                 dealScore(items);
 39                 break;
 40             case 2:
 41                 dealCourse(items);
 42                 break;
 43             case 3:
 44                 dealCourse(items);
 45                 break;
 46             case 4:
 47                 dealCourse(items);
 48                 break;
 49         }
 50     }
 51     Student getStudent(String stuId) {
 52         for (int i = 0; i < listStudent.size(); i++) {
 53             if (listStudent.get(i).getId().equals(stuId)) {
 54                 return listStudent.get(i);
 55             }
 56         }
 57         return null;
 58     }
 59 
 60     Course getCourse(String courseName) {
 61         for (int i = 0; i < listCourse.size(); i++) {
 62             if (listCourse.get(i).getName().equals(courseName)) {
 63                 return listCourse.get(i);
 64             }
 65         }
 66         return null;
 67     }
 68 
 69     Class getCls(String clsId) {
 70         for (int i = 0; i < listCls.size(); i++) {
 71             if (listCls.get(i).getId().equals(clsId)) {
 72                 return listCls.get(i);
 73             }
 74         }
 75         return null;
 76     }
 77 
 78 
 79     public ArrayList<SelectCourse> getStudentSelects(String stuId) {
 80         ArrayList<SelectCourse> stuSelects = new ArrayList<>();
 81         for (SelectCourse sc : listSelectCourse) {
 82             if (stuId.equals(sc.student.getId())) {
 83                 stuSelects.add(sc);
 84             }
 85         }
 86         return stuSelects;
 87     }
 88 
 89     public ArrayList<SelectCourse> getCourseSelects(String courseName) {
 90         ArrayList<SelectCourse> courseSelects = new ArrayList<>();
 91         for (SelectCourse sc : listSelectCourse) {
 92             if (courseName.equals(sc.course.getName())) {
 93                 courseSelects.add(sc);
 94             }
 95         }
 96         return courseSelects;
 97     }
 98 
 99     public ArrayList<SelectCourse> getClassSelects(String classId) {
100         ArrayList<SelectCourse> clsSelects = new ArrayList<>();
101         for (SelectCourse sc : listSelectCourse) {
102             if (classId.equals(sc.student.cls.getId())){
103                 clsSelects.add(sc);
104             }
105         }
106         return clsSelects;
107     }
108     public int getAvgTotalScore(ArrayList<SelectCourse> courseSelects) {
109         int sum = 0;
110         for (SelectCourse sc : courseSelects) {
111             sum += sc.score.getTotal();
112         }
113         return sum / courseSelects.size();
114     }
115 
116     private void dealCourse(String[] items) {
117         if(items.length==3){
118             String courseName = items[0];
119             String courseType = items[1];
120             String checkType = items[2];
121             Course course = new Course(courseName, courseType, checkType);
122             if (!checkCourse(course))
123                 return;
124             if (getCourse(courseName) == null) {
125                 listCourse.add(course);
126             }
127         }
128         else if(items.length==5){
129             String courseName = items[0];
130             String courseType = items[1];
131             String checkType = items[2];
132             ArrayList<String> prop=new ArrayList<>();
133             prop.add(items[3]);
134             prop.add(items[4]);
135             Course course=new Course(courseName,courseType,checkType,2,prop);
136             if (!checkCourse(course))
137                 return;
138             if (!checkProp(course))
139                 return;
140             if (getCourse(courseName) == null) {
141                 listCourse.add(course);
142             }
143         }
144         else {
145             String courseName = items[0];
146             String courseType = items[1];
147             String checkType = items[2];
148             int count=Integer.parseInt(items[3]);
149             ArrayList<String> prop=new ArrayList<>();
150             for (int i=4;i<items.length;i++){
151                 prop.add(items[i]);
152             }
153             Course course=new Course(courseName,courseType,checkType,count,prop);
154             if (!checkCourse(course))
155                 return;
156             if(!checkCount(course))
157                 return;
158             if (!checkProp(course))
159                 return;
160             if (getCourse(courseName) == null) {
161                 listCourse.add(course);
162             }
163         }
164     }
165     private void dealScore(String[] items) {
166         String stuId = items[0];
167         String stuName = items[1];
168         String courseName = items[2];
169         String clsId = stuId.substring(0, 6);
170         Class cls;
171         Student stu;
172         cls = getCls(clsId);
173         if (cls == null) {
174             cls = new Class(clsId);
175             listCls.add(cls);
176         }
177         stu = getStudent(stuId);
178         if (stu == null) {
179             stu = new Student(stuName, stuId);
180             listStudent.add(stu);
181             cls.addStudent(stu);
182         }
183         stu.setCls(cls);
184         Course course = getCourse(courseName);
185         if (course == null) {
186             System.out.println(courseName + " does not exist");
187             return;
188         }
189         if (!checkMethod(items, course))
190             return;
191         Score score;
192         PartScore partScore;
193         if (items.length == 4) {
194             ArrayList<String> grade=new ArrayList<>();
195             grade.add(items[3]);
196             ArrayList<String> prop=new ArrayList<>();
197             prop.add("1");
198             partScore=new PartScore(grade,prop);
199             score=new Score(partScore);
200         } else if(items.length==5) {
201             ArrayList<String> grade=new ArrayList<>();
202             grade.add(items[3]);
203             grade.add(items[4]);
204             partScore=new PartScore(grade,course.getProp());
205             score=new Score(partScore);
206         }
207         else {
208             ArrayList<String> grade=new ArrayList<>();
209             for(int i=3;i<items.length;i++){
210                 grade.add(items[i]);
211             }
212             partScore=new PartScore(grade,course.getProp());
213             score=new Score(partScore);
214         }
215         if (existChooseCourse(stu, course))
216             return;
217         SelectCourse selectCourse = new SelectCourse(course, stu, score);
218         listSelectCourse.add(selectCourse);
219     }
220 
221     boolean existChooseCourse(Student stu, Course course) {
222         for (int i = 0; i < listSelectCourse.size(); i++) {
223             if (listSelectCourse.get(i).getCourse().getName().equals(course.getName())) {
224                 if (listSelectCourse.get(i).getStudent().getName().equals(stu.getName())) {
225                     return true;
226                 }
227             }
228         }
229         return false;
230     }
231 
232     private boolean checkMethod(String[] items, Course course) {
233         String courseType = course.getMethod();
234         if (courseType.equals("考试") && items.length == 5) {
235             return true;
236         }
237         if (courseType.equals("考察") && items.length == 4) {
238             return true;
239         }
240         if(courseType.equals("实验")&&items.length==(3+course.getCount())){
241             return true;
242         }
243         System.out.println(items[0] + " " + items[1] + " : access mode mismatch");
244         return false;
245     }
246 
247     boolean checkCourse(Course course) {
248         if (course.getType().equals("必修")&&course.getMethod().equals("考试"))
249             return true;
250         if (course.getType().equals("选修") && (course.getMethod().equals("考试")||course.getMethod().equals("考察")))
251             return true;
252         if (course.getType().equals("实验")&&course.getMethod().equals("实验"))
253             return true;
254         System.out.println(course.getName() + " : course type & access mode mismatch");
255         return false;
256     }
257     boolean checkProp(Course course){
258         int sum=0;
259         for (int i=0;i<course.getProp().size();i++){
260             sum+=Float.parseFloat(course.getProp().get(i))*100;
261         }
262         if(sum!=100){
263             System.out.println(course.getName()+" : weight value error");
264             return false;
265         }
266         else
267             return true;
268     }
269     boolean checkCount(Course course){
270         if(!(course.getCount()==course.getProp().size())){
271             System.out.println(course.getName()+" : number of scores does not match");
272             return false;
273         }
274         else
275             return true;
276     }
277 
278     public void showCourse() {
279         Collections.sort(listCourse);
280         for (int i = 0; i < listCourse.size(); i++) {
281             Course course = listCourse.get(i);
282             ArrayList<SelectCourse> courseSelects = getCourseSelects(course.getName());
283             if (courseSelects.size() == 0) {
284                 System.out.println(course.getName() + " has no grades yet");
285             } else {
286                 System.out.println(course.getName()+" "+getAvgTotalScore(courseSelects));
287             }
288         }
289     }
290 
291     public void showStudents() {
292         Collections.sort(listStudent);
293         for (int i = 0; i < listStudent.size(); i++) {
294             Student stu = listStudent.get(i);
295             ArrayList<SelectCourse> stuCourseSelects = getStudentSelects(stu.getId());
296             if (stuCourseSelects.size() != 0) {
297                 System.out.println(stu.getId() + " " + stu.getName() + " " + getAvgTotalScore(stuCourseSelects));
298             } else {
299                 System.out.println(stu.getId() + " " + stu.getName() + " did not take any exams");
300             }
301         }
302     }
303 
304     public void showClasses() {
305         Collections.sort(listCls);
306         for (int i = 0; i < listCls.size(); i++) {
307             Class cls = listCls.get(i);
308             ArrayList<SelectCourse> clsCourseSelects = getClassSelects(cls.getId());
309             if (clsCourseSelects.size() != 0) {
310                 System.out.println(cls.getId() + " " + getAvgTotalScore(clsCourseSelects));
311             } else {
312                 System.out.println(cls.getId() + " has no grades yet");
313             }
314         }
315     }
316 }
317 class InputMatching {
318     InputMatching(){}
319     public static int matchingInput(String s) {
320         //考察课程
321         if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)")){
322             return 2;
323         }
324         //成绩
325         if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"+" "+
326                 "([1-9]?[0-9]|100)"+"(\\s([1-9]?[0-9]|100))?")){
327             return 1;
328         }
329         //实验成绩
330         if(s.matches("\\d{8}"+" "+"[^ \\t]{1,10}"+" "+"[^ \\t]{1,10}"
331                 +"(\\s([1-9]?[0-9]|100)){1,10}")){
332             return 1;
333         }
334         //考试课程
335         if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)"+" "+"(0\\.[1-9])"+" "+"(0\\.[1-9])"))
336             return 3;
337         //实验课程
338         if(s.matches("[^ \\t]{1,10}"+" "+"(选修|必修|实验)"+" "+"(考试|考察|实验)"+" "+"[4-9]"
339                 +"(\\s(0\\.[1-9])){1,10}"))
340             return 4;
341         return 0;
342     }
343 }
344 class SelectCourse {
345     Student student;
346     Course course;
347     Score score;
348 
349 
350     public SelectCourse(Course course, Student student, Score score) {
351         this.student = student;
352         this.course = course;
353         this.score = score;
354     }
355 
356     public Student getStudent() {
357         return student;
358     }
359 
360     public void setStudent(Student student) {
361         this.student = student;
362     }
363 
364     public Course getCourse() {
365         return course;
366     }
367 
368     public void setCourse(Course course) {
369         this.course = course;
370     }
371 
372     public Score getGrade() {
373         return score;
374     }
375 
376     public void setGrade(Score score) {
377         this.score = score;
378     }
379 }
380 class Student implements Comparable<Student> {
381     String name;
382     String Id;
383     Class cls;
384 
385     public Student(String name, String id) {
386         this.name = name;
387         Id = id;
388     }
389     public String getName() {
390         return name;
391     }
392 
393     public void setName(String name) {
394         this.name = name;
395     }
396 
397     public String getId() {
398         return Id;
399     }
400 
401     public void setId(String id) {
402         Id = id;
403     }
404 
405     public Class getCls() {
406         return cls;
407     }
408 
409     public void setCls(Class cls) {
410         this.cls = cls;
411     }
412 
413     public int compareTo(Student o) {
414         return getId().compareTo(o.getId());
415     }
416 }
417 class Class implements Comparable<Class> {
418     String id;
419     ArrayList<Student> listStudent = new ArrayList<>();
420     public Class(String id) {
421         this.id=id;
422     }
423     public String getId() {
424         return id;
425     }
426     void addStudent(Student stu) {
427         listStudent.add(stu);
428     }
429 
430     @Override
431     public int compareTo(Class o) {
432         return getId().compareTo(o.getId());
433     }
434 }
435 class Course implements Comparable<Course>{
436     String name;
437     String type;
438     String method;
439     int count;
440     ArrayList<String> prop;
441 
442     public Course(String name, String type, String method, int count, ArrayList<String> prop) {
443         this.name = name;
444         this.type = type;
445         this.method = method;
446         this.count = count;
447         this.prop = prop;
448     }
449 
450     public Course(String name, String type, String method) {
451         this.name = name;
452         this.type = type;
453         this.method = method;
454     }
455 
456     public String getName() {
457         return name;
458     }
459 
460     public void setName(String name) {
461         this.name = name;
462     }
463     public String getType() {
464         return type;
465     }
466 
467     public void setType(String type) {
468         this.type = type;
469     }
470 
471     public String getMethod() {
472         return method;
473     }
474 
475     public void setMethod(String method) {
476         this.method = method;
477     }
478 
479     public int getCount() {
480         return count;
481     }
482 
483     public ArrayList<String> getProp() {
484         return prop;
485     }
486 
487     public int compareTo(Course o) {
488         Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
489         return compare.compare(name, o.getName());
490     }
491 }
492 class Score {
493     private PartScore partScore;
494 
495     public Score(PartScore partScore) {
496         this.partScore = partScore;
497     }
498     public float getTotal(){
499         float sum=0;
500         for (int i=0;i<partScore.getProp().size();i++){
501             sum+=Float.parseFloat(partScore.getProp().get(i))*Float.parseFloat(partScore.getGrade().get(i));
502         }
503         return sum;
504     }
505 }
506 
507 class PartScore{
508     private ArrayList<String> grade;
509     private ArrayList<String> prop;
510 
511     public PartScore(ArrayList<String> grade, ArrayList<String> prop) {
512         this.grade = grade;
513         this.prop = prop;
514     }
515 
516     public ArrayList<String> getGrade() {
517         return grade;
518     }
519 
520     public void setGrade(ArrayList<String> grade) {
521         this.grade = grade;
522     }
523 
524     public ArrayList<String> getProp() {
525         return prop;
526     }
527 
528     public void setProp(ArrayList<String> prop) {
529         this.prop = prop;
530     }
531 }

课程成绩统计程序-3

以下是我的设计类图：

程序-3需要修改类设计，我将原本的AssessmentScore类和ExamScore类继承Score类，直接改成只有Score类和PartScore类，Score类和PartScore类一起使用，以便计算学生总成绩。Score类的getTotal()方法使用PartScore对象的属性进行计算，根据每个部分成绩和所占比例的乘积来计算学生的总成绩。

接下来，就是根据两个分数类修改其它部分的代码，包括输入格式的匹配部分、计算分数、输出格式部分和对输入课程的处理、对输入学生成绩的处理等。

三、踩坑心得

　　这里主要对训练集09的统计Java程序中关键词的出现次数踩的一个坑，我是万万没想到，过不去的测试点其实是一个“=”

将原先的代码：

while (!(line = in.nextLine()).equals("exit")) {
　　code.append(line).append("\n");
}

改成：

while (!(line = in.nextLine()).equals("exit")) {
　　line=line.replaceAll("=","a");
　　code.append(line).append("\n");
}

就行了。。。

　　但其实这样做，面向对象编程也就变成了面向测试点编程，还是因为原本我写的代码没有考虑全所有的情况，导致有很多符号没有在我的处理情况内，比如“！=” “&” “+” “-”等等。

四、改进建议

　　这里主要写对课程成绩统计程序-1的代码进行改进。

改进后的代码如下：

  1 import java.util.ArrayList;
  2 import java.util.Collections;
  3 import java.text.Collator;
  4 import java.util.Comparator;
  5 import java.util.Scanner;
  6 public class Main {
  7     public static void main(String[] args) {
  8         Scanner in=new Scanner(System.in);
  9         String info=in.nextLine();
 10         Handle handle=new Handle();
 11         while(!info.equals("end")){
 12             handle.Handle(info);
 13             info=in.nextLine();
 14         }
 15         handle.showStudents();
 16         handle.showCourse();
 17         handle.showClasses();
 18     }
 19 }
 20 class Handle {
 21     ArrayList<Course> listCourse = new ArrayList<>();
 22     ArrayList<Student> listStudent = new ArrayList<>();
 23     ArrayList<SelectCourse> listSelectCourse = new ArrayList<>();
 24     ArrayList<Class> listCls = new ArrayList<>();
 25 
 26     public Handle() {
 27     }
 28 
 29     public void Handle(String s) {
 30         InputMatching im=new InputMatching();
 31         int i = im.matchingInput(s);
 32         String[] items = s.split(" ");
 33         switch (i){
 34             case 0:
 35                 System.out.println("wrong format");
 36                 break;
 37             case 1:
 38                 dealCourse(items);
 39                 break;
 40             case 2:
 41                 dealScore(items);
 42                 break;
 43         }
 44     }
 45     Student getStudent(String stuId) {
 46         for (int i = 0; i < listStudent.size(); i++) {
 47             if (listStudent.get(i).getId().equals(stuId)) {
 48                 return listStudent.get(i);
 49             }
 50         }
 51         return null;
 52     }
 53 
 54     Course getCourse(String courseName) {
 55         for (int i = 0; i < listCourse.size(); i++) {
 56             if (listCourse.get(i).getName().equals(courseName)) {
 57                 return listCourse.get(i);
 58             }
 59         }
 60         return null;
 61     }
 62 
 63     Class getCls(String clsId) {
 64         for (int i = 0; i < listCls.size(); i++) {
 65             if (listCls.get(i).getId().equals(clsId)) {
 66                 return listCls.get(i);
 67             }
 68         }
 69         return null;
 70     }
 71 
 72 
 73     public ArrayList<SelectCourse> getStudentSelects(String stuId) {
 74         ArrayList<SelectCourse> stuSelects = new ArrayList<>();
 75         for (SelectCourse cs : listSelectCourse) {
 76             if (stuId.equals(cs.student.getId())) {
 77                 stuSelects.add(cs);
 78             }
 79         }
 80         return stuSelects;
 81     }
 82 
 83 
 84     public ArrayList<SelectCourse> getCourseSelects(String courseName) {
 85         ArrayList<SelectCourse> courseSelects = new ArrayList<>();
 86         for (SelectCourse cs : listSelectCourse) {
 87             if (courseName.equals(cs.course.getName())) {
 88                 courseSelects.add(cs);
 89             }
 90         }
 91         return courseSelects;
 92     }
 93 
 94     public ArrayList<SelectCourse> getClassSelects(String classId) {
 95         ArrayList<SelectCourse> clsSelects = new ArrayList<>();
 96         for (SelectCourse sc : listSelectCourse) {
 97             if (classId.equals(sc.student.cls.getId())){
 98                 clsSelects.add(sc);
 99             }
100         }
101         return clsSelects;
102     }
103     public int getAvgTotalScore(ArrayList<SelectCourse> listSelectCourse) {
104         int sum = 0;
105         for (SelectCourse cs : listSelectCourse) {
106             sum += cs.score.getTotalScore();
107         }
108         return sum / listSelectCourse.size();
109     }
110     public int getAvgUsualScore(ArrayList<SelectCourse> courseSelects) {
111         int sum = 0;
112         for (SelectCourse cs : courseSelects) {
113             sum += ((ExamScore)cs.score).getUsualScore();
114         }
115         return sum / courseSelects.size();
116     }
117     public int getAvgFinalScore(ArrayList<SelectCourse> courseSelects) {
118         int sum = 0;
119         for (SelectCourse cs : courseSelects) {
120             sum += cs.score.getFinalScore();
121         }
122         return sum / courseSelects.size();
123     }
124 
125     private void dealCourse(String[] items) {
126         String courseName = items[0];
127         String courseType = items[1];
128         String checkType = items[2];
129         Course course = new Course(courseName, courseType, checkType);
130         if (!checkCourse(course))
131             return;
132         if (getCourse(courseName) == null) {
133             //course = new Course(courseName, courseType, checkType);
134             listCourse.add(course);
135         }
136     }
137     private void dealScore(String[] items) {
138         String stuId = items[0];
139         String stuName = items[1];
140         String courseName = items[2];
141         String clsId = stuId.substring(0, 6);
142         Class cls;
143         Student stu;
144         cls = getCls(clsId);
145         if (cls == null) {
146             cls = new Class(clsId);
147             listCls.add(cls);
148         }
149         stu = getStudent(stuId);
150         if (stu == null) {
151             stu = new Student(stuName, stuId);
152             listStudent.add(stu);
153             cls.addStudent(stu);
154         }
155         stu.setCls(cls);
156         Course course = getCourse(courseName);
157         if (course == null) {
158             System.out.println(courseName + " does not exist");
159             return;
160         }
161         if (!checkMethod(items, course))
162             return;
163         Score score;
164         if (items.length == 4) {
165             int finalScore = Integer.parseInt(items[3]);
166             score = new AssessmentScore(finalScore);
167         } else {
168             int usualScore = Integer.parseInt(items[3]);
169             int finalScore = Integer.parseInt(items[4]);
170             score = new ExamScore(usualScore, finalScore);
171         }
172         if (existChooseCourse(stu, course))
173             return;
174         SelectCourse selectCourse = new SelectCourse(course, stu, score);
175         listSelectCourse.add(selectCourse);
176     }
177 
178     boolean existChooseCourse(Student stu, Course course) {
179         for (int i = 0; i < listSelectCourse.size(); i++) {
180             if (listSelectCourse.get(i).getCourse().getName().equals(course.getName())) {
181                 if (listSelectCourse.get(i).getStudent().getName().equals(stu.getName())) {
182                     return true;
183                 }
184             }
185         }
186         return false;
187     }
188 
189     private boolean checkMethod(String[] items, Course course) {
190         String courseType = course.getMethod();
191         if (courseType.equals("考试") && items.length == 5) {
192             return true;
193         }
194         if (courseType.equals("考察") && items.length == 4) {
195             return true;
196         }
197         System.out.println(items[0] + " " + items[1] + " : access mode mismatch");
198         return false;
199     }
200 
201     boolean checkCourse(Course course) {
202         if (course.getType().equals("必修")&&course.getMethod().equals("考试"))
203             return true;
204         if (course.getType().equals("选修") && (course.getMethod().equals("考试")||course.getMethod().equals("考察")))
205             return true;
206         System.out.println(course.getName() + " : course type & access mode mismatch");
207         return false;
208     }
209 
210 
211     public void showCourse() {
212         Collections.sort(listCourse);
213         for (int i = 0; i < listCourse.size(); i++) {
214             Course course = listCourse.get(i);
215             ArrayList<SelectCourse> courseSelects = getCourseSelects(course.getName());
216             if (courseSelects.size() == 0) {
217                 System.out.println(course.getName() + " has no grades yet");
218             } else {
219                 if (course.getMethod().equals("考试")) {
220                     System.out.println(course.getName() + " " + getAvgUsualScore(courseSelects) + " " + getAvgFinalScore(courseSelects) + " " + getAvgTotalScore(courseSelects));
221                 } else {
222                     System.out.println(course.getName() + " " + getAvgFinalScore(courseSelects) + " " + getAvgTotalScore(courseSelects));
223                 }
224             }
225         }
226     }
227 
228     public void showStudents() {
229         Collections.sort(listStudent);
230         for (int i = 0; i < listStudent.size(); i++) {
231             Student stu = listStudent.get(i);
232             ArrayList<SelectCourse> stuCourseSelects = getStudentSelects(stu.getId());
233             if (stuCourseSelects.size() != 0) {
234                 System.out.println(stu.getId() + " " + stu.getName() + " " + getAvgTotalScore(stuCourseSelects));
235             } else {
236                 System.out.println(stu.getId() + " " + stu.getName() + " did not take any exams");
237             }
238         }
239     }
240 
241     public void showClasses() {
242         Collections.sort(listCls);
243         for (int i = 0; i < listCls.size(); i++) {
244             Student stu = listStudent.get(i);
245             Class cls = listCls.get(i);
246             //ArrayList stuCls = getStudentSelects(stu.getId().substring(0, 6));
247             ArrayList<SelectCourse> clsCourseSelects = getClassSelects(stu.getId().substring(0,6));
248             if (clsCourseSelects.size() != 0) {
249                 System.out.println(cls.getId() + " " + getAvgTotalScore(clsCourseSelects));
250             } else {
251                 System.out.println(cls.getId() + " has no grades yet");
252             }
253         }
254     }
255 }
256 class SelectCourse {
257     Student student;
258 
259     Course course;
260     Score score;
261 
262 
263     public SelectCourse(Course course, Student student, Score score) {
264         this.student = student;
265         this.course = course;
266         this.score = score;
267     }
268 
269     public Student getStudent() {
270         return student;
271     }
272 
273     public void setStudent(Student student) {
274         this.student = student;
275     }
276 
277     public Course getCourse() {
278         return course;
279     }
280 
281     public void setCourse(Course course) {
282         this.course = course;
283     }
284 
285     public Score getGrade() {
286         return score;
287     }
288 
289     public void setGrade(Score score) {
290         this.score = score;
291     }
292 }
293 class Student implements Comparable<Student> {
294     String name;
295     String Id;
296     Class cls;
297 
298     public Student(String name, String id) {
299         this.name = name;
300         Id = id;
301     }
302     public String getName() {
303         return name;
304     }
305 
306     public void setName(String name) {
307         this.name = name;
308     }
309 
310     public String getId() {
311         return Id;
312     }
313 
314     public void setId(String id) {
315         Id = id;
316     }
317 
318     public Class getCls() {
319         return cls;
320     }
321 
322     public void setCls(Class cls) {
323         this.cls = cls;
324     }
325 
326     public int compareTo(Student o) {
327         return getId().compareTo(o.getId());
328     }
329 }
330 
331 class Class implements Comparable<Class> {
332     String cls;
333     String id;
334     ArrayList<Student> listStudent = new ArrayList<>();
335     public Class(String id) {
336         this.id=id;
337     }
338     public String getId() {
339         return id;
340     }
341     void addStudent(Student stu) {
342         listStudent.add(stu);
343     }
344     public String getCls() {
345         return cls;
346     }
347     public void setCls(String cls) {
348         this.cls = cls;
349     }
350 
351     public void setId(String id) {
352         this.id = id;
353     }
354 
355     @Override
356     public int compareTo(Class o) {
357         return getId().compareTo(o.getId());
358     }
359 }
360 
361 
362 class InputMatching {
363     InputMatching(){}
364     static String stuNumMatching = "\\d{8}";//8个0-9的数字
365     static String stuNameMatching = "[^ \\t]{1,10}";//1到10个非空格（TAB）字符
366     static String scoreMatching = "([1-9]?[0-9]|100)";
367     static String courseNameMatching = "[^ \\t]{1,10}";//1到10个非空格（TAB）字符
368     static String courseTypeMatching = "(选修|必修)";
369     static String checkcourseTypeMatching = "(考试|考察)";
370     //cousrInput用于定义课程信息模式（正则表达式）
371     static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
372     //scoreInput用于定义成绩信息模式（正则表达式）
373     static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
374             scoreMatching + "(\\s([1-9]?[0-9]|100))?";
375     public static int matchingInput(String s) {
376         if (matchingCourse(s)) {
377             return 1;
378         }
379         if (matchingScore(s)) {
380             return 2;
381         }
382         return 0;
383     }
384     private static boolean matchingCourse(String s) {
385         return s.matches(courseInput);
386     }
387 
388     private static boolean matchingScore(String s) {
389         //System.out.println(match);
390         return s.matches(scoreInput);
391     }
392 }
393 class Course implements Comparable<Course>{
394     String name;
395     String type;
396     String method;
397     public Course(String name, String type, String method) {
398         this.name = name;
399         this.type = type;
400         this.method = method;
401     }
402 
403     public String getName() {
404         return name;
405     }
406 
407     public void setName(String name) {
408         this.name = name;
409     }
410     public String getType() {
411         return type;
412     }
413 
414     public void setType(String type) {
415         this.type = type;
416     }
417 
418     public String getMethod() {
419         return method;
420     }
421 
422     public void setMethod(String method) {
423         this.method = method;
424     }
425 
426     public int compareTo(Course o) {
427         Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
428         return compare.compare(name, o.getName());
429     }
430 }
431 abstract  class Score {
432     int finalScore;
433     int totalScore;
434     public Score(int finalScore, int totalScore) {
435         this.finalScore = finalScore;
436         this.totalScore = totalScore;
437     }
438 
439     public Score(int finalScore){
440         this.finalScore=finalScore;
441     }
442     public int getFinalScore() {
443         return finalScore;
444     }
445 
446     public void setFinalScore(int finalScore) {
447         this.finalScore = finalScore;
448     }
449 
450     public int getTotalScore() {
451         return totalScore;
452     }
453 
454     public void setTotalScore(int totalScore) {
455         this.totalScore = totalScore;
456     }
457 }
458 class AssessmentScore extends Score //考察成绩
459 {
460     public AssessmentScore(int finalScore) {
461         super(finalScore);
462         this.totalScore = finalScore;
463     }
464 }
465 class ExamScore extends Score//考试成绩
466 {
467 
468     private int usualScore;
469 
470     public int getUsualScore() {
471         return usualScore;
472     }
473 
474     public void setUsualScore(int usualScore) {
475         this.usualScore = usualScore;
476     }
477 
478     public ExamScore(int usualScore, int finalScore) {
479         super(finalScore);
480         this.usualScore=usualScore;
481         this.totalScore = (int) (usualScore * 0.3 + finalScore * 0.7);
482     }
483 }

课程成绩统计程序-1改进

这里主要是修改了InputMatching类内的正则表达式进行了修改，还有在SelectCourse的List内添加选课类的部分进行了修改，如下：

public ArrayList<SelectCourse> getClassSelects(String classId) {
    ArrayList<SelectCourse> clsSelects = new ArrayList<>();
    for (SelectCourse sc : listSelectCourse) {
        if (classId.equals(sc.student.cls.getId())){
            clsSelects.add(sc);
        }
    }
    return clsSelects;
}
除此之外还修改了一些小细节，这里就不详细说明了。

五、总结

　　　　本阶段学习到了很多内容，包括继承、多态、接口，Set、Map、List等等，还有Comparable接口和Comparator接口，尤其经过三次课程成绩统计程序，对类的设计更加有了新的理解，在设计过程中，要重点考虑了系统的可扩展性和易用性。通过合理的类设计和方法封装，使得系统具有良好的扩展性，可以方便地添加新的功能和进行修改。

　　　　对于本门课程，在教学理念（OBE）方面，确确实实是提高了学生的主动性，但是有时可以稍稍指明一点方向，有时学生像无头苍蝇一样不知道如何去学，比如我。在教学方法（边讲边练）方面，我认为讲可以再多一点点。在教学组织（线上线下混合式教学）方面，我认为没什么问题。在教学过程（PTA题目集驱动）方面，PTA是一个很好提高编程能力的平台，能够很好地辅助学生消化所学的内容。在教学模式（BOPPPS）方面，我认为可以更加注重学生组内讨论，加强团队沟通能力。

　　　　以上是我对本门课程的一些想法。

　　　　对于我自身，我知自己还有很多不足，少年还须努力。

posted @ 2023-06-27 23:24 Jally373 阅读(41) 评论(0) 收藏举报

刷新页面返回顶部

Jally373

OOP第三次作业总结（222019班22201321）

一、前言

二、设计与分析

三、踩坑心得

四、改进建议

五、总结

公告