（1）前言：本次大作业的题目量一般，本次大作业由于前面的菜单迭代系列已经基本完成，本次开始新的系列，课程统计程序系列，本次题目比较简单，主要原因是老师已经在课上对基本的逻辑以及一些设计的思路和结构已经非常的详细。有了这一个清晰的大框架之后，设计代码还是比较容易的，需要添加一些基本的属性和方法。
（2）设计与分析：
7-3 课程成绩统计程序-2 分数 60 作者 蔡轲 单位 南昌航空大学课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩的平均分
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
实验次数至少4次，不超过9次
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
考试/考察课程成绩格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
实验课成绩格式：课程名称+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
输入样例1:
在这里给出一组输入。例如：
java 实验 实验
20201103 张三 java 4 70 80 90
end
输出样例1:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例2:
在这里给出一组输入。例如：
java 实验 实验
20201103 张三 java 3 70 80 90
end
输出样例2:
在这里给出相应的输出。例如：
wrong format
java has no grades yet
输入样例3:
在这里给出一组输入。例如：
java 必修 实验
20201103 张三 java 3 70 80 90 100
end
输出样例3:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
wrong format
输入样例4:
在这里给出一组输入。例如：
java 必修 实验
20201103 张三 java 4 70 80 90 105
end
输出样例4:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
wrong format
输入样例5:
在这里给出一组输入。例如：
java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end
输出样例5:
在这里给出相应的输出。例如：
20201101 王五 76
20201103 张三 85
20201118 郑觉先 80
20201132 王萍 40
20201209 赵仙芝 76
20201213 黄红 82
20201216 李四 78
20201220 朱重九 70
20201302 李梦涵 68
20201307 张少军 83
20201325 崔瑾 82
20201328 刘和宇 77
C语言 65 65
java 78 78
java实验 77
编译原理 81 84 82
202011 70
202012 76
202013 77
程序的设计思路与分析：
-
设计数据结构：
- 定义课程信息类 Course，包括课程名称、性质、考核方式等属性。
- 定义学生信息类 Student，包括学号、姓名等属性。
- 定义成绩信息类 Grade，包括学号、课程名称、平时成绩、期末成绩等属性。
-
解析输入信息：
- 读取输入信息，解析课程信息和学生成绩信息，保存到对应的数据结构中。
- 检查输入信息的格式和约束，如成绩范围、学号格式、课程名称长度等。
-
计算学生总成绩和课程平均成绩：
- 根据课程性质和考核方式计算学生总成绩，包括必修课、选修课、实验课。
- 计算课程的平均成绩，包括平时成绩、期末成绩、实验成绩。
-
输出结果：
- 输出学生所有课程总成绩的平均分，单门课程成绩平均分，单门课程总成绩平均分，班级所有课程总成绩平均分。
- 按照指定的格式输出结果，包括学号、姓名、课程名称、班级号等信息。
-
异常处理：
- 对于输入信息的异常情况，如格式错误、课程名称不匹配、成绩超出范围等，根据题目要求输出相应的错误信息。
代码如下：
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<CourseSelect> courseSelects = new ArrayList<>();
ArrayList<Course> courses = new ArrayList<>();
ArrayList<Student> students = new ArrayList<>();
ArrayList<Class> classes = new ArrayList<>();
Scanner in =new Scanner(System.in);
String input = in.nextLine();
while (!input.equals("end")) {
String[] buff = input.split(" ");
if (input.matches("[\\u4e00-\\u9fa5a-zA-Z]{1,10} (必修|选修|实验) (考试|考察|实验)")) {//输入的是课程信息
if (buff[1].equals("必修") && buff[2].equals("考察")||buff[1].equals("必修") && buff[2].equals("实验")||buff[1].equals("选修") && buff[2].equals("实验")) { //课程性质和课程的考核方式不匹配
System.out.println(buff[0] + " : course type & access mode mismatch");
} else{
int isSame = 0;
for (int i=0;i < courses.size();i++) {
if (courses.get(i).courseName.equals(buff[0])) {
isSame = 1;//输入重复的课程
break;
}
}
if (isSame == 0) {
Course course = new Course();
course.courseName = buff[0];
course.courseType = buff[1];
course.courseMethod = buff[2];
courses.add(course);
}
}
} else if (input.matches("\\d{8} [\\u4e00-\\u9fa5a-zA-Z]{1,10} [\\u4e00-\\u9fa5a-zA-Z]{1,10} ([4-9])( ([0-9]|[1-9][0-9]|100))*")
|| input.matches("\\d{8} [\\u4e00-\\u9fa5a-zA-Z]{1,10} [\\u4e00-\\u9fa5a-zA-Z]{1,10} ([0-9]|[1-9][0-9]|100)( ([0-9]|[1-9][0-9]|100))?")) {//输入的是选课
int cnt = 0;
for (int i = 0; i < courses.size(); i++) {
if (courses.get(i).courseName.equals(buff[2])) {
i = cnt;
}
else{
cnt = -1;
}
}
if (courses.isEmpty()) {
System.out.println(buff[2] + " does not exist");
} else {
//有这门课
if(cnt != -1) {
int i = cnt;
//输入的成绩数量和课程的考核方式不匹配
if ((courses.get(i).courseMethod.equals("考试") && buff.length != 5) || (courses.get(i).courseMethod.equals("考察") && buff.length != 4)|| (courses.get(i).courseMethod.equals("实验") && Integer.parseInt(buff[3]) != buff.length - 4)) {
System.out.println(buff[0] + " " + buff[1] + " : access mode mismatch");
} else {
CourseSelect courseSelect = new CourseSelect();
Course course = new Course();
Student student = new Student();
//课程
course.courseName= buff[2];
courseSelect.course = course;
//学生
student.studentID= buff[0];
student.studentName= buff[1];
courseSelect.student = student;
//考试
if (buff.length == 5) {
ExamCourse exam = new ExamCourse();
exam.dailyScore = Integer.parseInt(buff[3]);
exam.finalScore = Integer.parseInt(buff[4]);
courseSelect.score = exam;
}
//考察
else if (buff.length == 4) {
InspectCourse inspect = new InspectCourse();
inspect.finalScore = Integer.parseInt(buff[3]);
courseSelect.score = inspect;
}
else {
int sum = 0;
ExperimentCourse experiment = new ExperimentCourse();
for (int j = 4;j < buff.length;j++) {
sum += Integer.parseInt(buff[j]);
}
sum = sum / (buff.length - 4);
experiment.averageScore = sum;
courseSelect.score = experiment;
}
courseSelects.add(courseSelect);
}
} else {//课程信息没有这门课
System.out.println(buff[2] + " does not exist");
}
}
// 学生信息与班级防止重复
//录入学生信息
int isSameStudent = 0;
for (int j=0;j < students.size();j++) {
if (students.get(j).studentID.equals(buff[0])) {
isSameStudent = 1;
break;
}
}
if (isSameStudent == 0) {
Student student = new Student();
student.studentID = buff[0];
student.studentName= buff[1];
students.add(student);
}
//录入班级信息
int isSameClass = 0;
for (int k=0;k < classes.size();k++) {
if (classes.get(k).className.equals(buff[0].substring(0, 6))) {
isSameClass = 1;
break;
}
}
if (isSameClass == 0) {
Class Classes = new Class();
Classes.className = buff[0].substring(0,6);
classes.add(Classes);
}
} else {
System.out.println("wrong format");
}
input = in.nextLine();
}
Student student = new Student();
Course course = new Course();
Class class1 = new Class();
student.showStudentScore(students,courseSelects);
course.showCourseScore(courses,courseSelects);
class1.showClassScore(classes,students);
}
}
class Class implements Comparable<Class> {
String className;
int classScore;
public String getClassName() {
return className;
}
public Class() {
}
@Override
public int compareTo(Class o) {
return this.getClassName().compareTo(o.getClassName());
}
public void showClassScore(ArrayList<Class>classes,ArrayList<Student>students){
for (int i=0;i < classes.size();i++) {//计算班级成绩
int cnt = 0;
int flag = 0;
for (int j=0;j < students.size();j++) {
if (classes.get(i).className.equals(students.get(j).studentID.substring(0,6)) && students.get(j).isHasGrade) {//是这个班级的学生且有成绩
flag = 1;
classes.get(i).classScore += students.get(j).studentScore;
cnt++;
}
}
if (flag == 1) {
classes.get(i).classScore = classes.get(i).classScore / cnt;
} else{
System.out.println(classes.get(i).className+ " has no grades yet");
}
}
Collections.sort(classes);//班级排序
for (int i=0;i < classes.size();i++) {
int flag = 0;
for (int j=0;j < students.size();j++) {
if (classes.get(i).className.equals(students.get(j).studentID.substring(0,6)) && students.get(j).isHasGrade) {//是这个班级的学生
flag = 1;
}
}
if (flag == 1) {
System.out.println(classes.get(i).className + " " + classes.get(i).classScore);
}
}
}
}
class Course {
String courseName;
String courseType;
String courseMethod;
int dailyAverage;
int testAverage;
int totalScore;
public String getName() {
return courseName;
}
public Course() {
}
public void showCourseScore(ArrayList<Course> courses, ArrayList<CourseSelect>courseSelects){
//计算课程成绩
for (int i=0;i < courses.size();i++) {
int cntExam = 0;
int cntInspect = 0;
int cntExperiment = 0;
int flag = 0;
for (int j=0;j < courseSelects.size();j++) {
if (courses.get(i).courseName.equals(courseSelects.get(j).course.courseName)) {
flag = 1;
if (courseSelects.get(j).score instanceof ExamCourse) { //考试
courses.get(i).dailyAverage += ((ExamCourse)courseSelects.get(j).score).getDailyScore();
courses.get(i).testAverage += ((ExamCourse)courseSelects.get(j).score).getFinalScore();
courses.get(i).totalScore += ((ExamCourse)courseSelects.get(j).score).getTotalScore();
cntExam++;
} else if (courseSelects.get(j).score instanceof InspectCourse) { //考察
courses.get(i).testAverage += ((InspectCourse)courseSelects.get(j).score).getFinalScore();
courses.get(i).totalScore += ((InspectCourse)courseSelects.get(j).score).getFinalScore();
cntInspect++;
}
else if (courseSelects.get(j).score instanceof ExperimentCourse) { //考察
courses.get(i).testAverage += ((ExperimentCourse)courseSelects.get(j).score).getAverageScore();
courses.get(i).totalScore += ((ExperimentCourse)courseSelects.get(j).score).getAverageScore();
cntExperiment++;
}
}
}
if (flag == 1) {
if (courses.get(i).courseMethod.equals("考试")) {
courses.get(i).dailyAverage = courses.get(i).dailyAverage / cntExam;
courses.get(i).testAverage = courses.get(i).testAverage / cntExam;
courses.get(i).totalScore = courses.get(i).totalScore / cntExam;
} else if (courses.get(i).courseMethod.equals("考察")) {
courses.get(i).testAverage= courses.get(i).testAverage / cntInspect;
courses.get(i).totalScore = courses.get(i).totalScore / cntInspect;
}
else if (courses.get(i).courseMethod.equals("实验")) {
courses.get(i).testAverage = courses.get(i).testAverage / cntExperiment;
courses.get(i).totalScore = courses.get(i).totalScore / cntExperiment;
}
} else{
System.out.println(courses.get(i).courseName + " has no grades yet");
}
}
//Course排序
Comparator<Course> comparator = new Comparator<>() {
Collator collator = Collator.getInstance(Locale.CHINA);
@Override
public int compare(Course o1, Course o2) {
return collator.compare(o1.getName(), o2.getName());
}
};
Collections.sort(courses, comparator);
for (int i=0;i < courses.size();i++) {
int isHasScore = 0;
for (int j=0;j < courseSelects.size();j++) {
if (courses.get(i).courseName.equals(courseSelects.get(j).course.courseName)) {
isHasScore = 1;
break;
}
}
if (isHasScore == 1) {
if (courses.get(i).courseMethod.equals("考试")) {
System.out.println(courses.get(i).courseName + " " + courses.get(i).dailyAverage + " " + courses.get(i).testAverage + " " + courses.get(i).totalScore);
} else if (courses.get(i).courseMethod.equals("考察")) {
System.out.println(courses.get(i).courseName + " " + courses.get(i).testAverage + " " + courses.get(i).totalScore);
}
else if (courses.get(i).courseMethod.equals("实验")) {
System.out.println(courses.get(i).courseName+ " " + courses.get(i).totalScore);
}
}
}
}
}
class CourseSelect {
Course course;
Student student;
Score score;
public CourseSelect() {
}
}
class ExamCourse extends Score {
int dailyScore;
int finalScore;
public ExamCourse() {
}
public int getDailyScore() {
return dailyScore;
}
public int getFinalScore() {
return finalScore;
}
public int getTotalScore() {
return (int) (dailyScore * 0.3 + finalScore * 0.7);
}
}
class InspectCourse extends Score {
int finalScore;
public int getFinalScore() {
return finalScore;
}
public InspectCourse() {
}
}
class Dish {
String name;//菜品名称
int unit_price; //单价
//int num;
int getPrice(int portion) {
int peic = 0;
if (portion == 1) {
peic = unit_price ;
} else if (portion == 2) {
peic = Math.round((float) (unit_price * 1.5)) ;
} else if (portion == 3) {
peic = (unit_price * 2) ;
}
return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
}
class Menu {
Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息
int count = 0;
Dish searthDish(String dishName){
Dish temd = null;
for(int i=count-1;i>=0;i--){
if(dishName.equals(dishs[i].name)){
temd = dishs[i];
break;
}
}
if(temd==null){
System.out.println(dishName+" does not exist");
}
return temd;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price){
Dish dh = new Dish();
dh.name = dishName;
dh.unit_price = unit_price;
count++;
return dh;
}//添加一道菜品信息
}
class Record {
int orderNum;//序号\
//int AntherOrderNum;
Dish d = new Dish();//菜品\
int num = 0;
int portion;//份额（1/2/3代表小/中/大份）\
//int exist = 1;
int getPrice(){
return d.getPrice(portion)*num;
}//计价，计算本条记录的价格\
}
class Order {
Record[] records = new Record[10];//保存订单上每一道的记录
int count = 0;//订单数量
void addARecord(int orderNum,String dishName,int portion,int num){
records[count] = new Record();
records[count].d.name = dishName;
records[count].orderNum = orderNum;
records[count].portion = portion;
records[count].num = num;
count++;
}//添加一条菜品信息到订单中。
int delARecordByOrderNum(int orderNum){
if(orderNum>count||orderNum<=0){
System.out.println("delete error;");
return 0;
}else {
return records[orderNum - 1].getPrice();
}
}//根据序号删除一条记录
}
class Table {
int tableNum;
String tableDtime;
int year,month,day,week,hh,mm,ss;
int sum = 0;//一桌价格 ；
// boolean f = true;
Order odt = new Order();
//Order odre = new Order();
float discnt = -1;
void Gettottalprice(){
if(discnt>0){
sum = Math.round(sum*discnt);
System.out.println("table " + tableNum + ": " + sum);
}else {
System.out.println("table " + tableNum + " out of opening hours");
}
}
void AheadProcess(String tableDtime){
this.tableDtime = tableDtime;
processTime();
discount();
}
void processTime(){//处理时间
String[] temp = tableDtime.split(" ");
tableNum = Integer.parseInt(temp[1]);
String[] temp1 = temp[2].split("/");
String[] temp2 = temp[3].split("/");
year = Integer.parseInt(temp1[0]);
month = Integer.parseInt(temp1[1]);
day = Integer.parseInt(temp1[2]);
Calendar c = Calendar.getInstance();
c.set(year, (month-1), day);
week = c.get(Calendar.DAY_OF_WEEK);
if(week==1)
week = 7;
else
week--;
hh = Integer.parseInt(temp2[0]);
mm = Integer.parseInt(temp2[1]);
ss = Integer.parseInt(temp2[2]);
}
//void CheckAtime(){
// f= !(discnt < 0);
// }
void discount(){
if(week>=1&&week<=5)
{
if(hh>=17&&hh<20)
discnt=0.8F;
else if(hh==20&&mm<30)
discnt=0.8F;
else if(hh==20&&mm==30&&ss==0)
discnt=0.8F;
else if(hh>=11&&hh<=13||hh==10&&mm>=30)
discnt=0.6F;
else if(hh==14&&mm<30)
discnt=0.6F;
else if(hh==14&&mm==30&&ss==0)
discnt=0.6F;
}
else
{
if(hh>=10&&hh<=20)
discnt= 1.0F;
else if(hh==9&&mm>=30)
discnt= 1.0F;
else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
discnt= 1.0F;
}
}
}
class ExperimentCourse extends Score{
int[] daily = new int[10];
int averageScore;
int totalScore;
public ExperimentCourse() {
}
public int[] getDaily() {
return daily;
}
public int getTotalScore() {
return totalScore;
}
public int getAverageScore() {
return averageScore;
}
}
abstract class Score {
public Score() {
}
}
class Student implements Comparable<Student> {
String studentID;
String studentName;
int studentScore;
boolean isHasGrade = false;
public Student() {
}
public String getStudentID() {
return studentID;
}
@Override
public int compareTo(Student o) {
return this.getStudentID().compareTo(o.getStudentID()) ;
}
public void showStudentScore(ArrayList<Student>students,ArrayList<CourseSelect>courseSelects){
for (int i=0;i < students.size();i++) { //计算每个学生的总成绩
int cnt = 0;
for (int j=0;j < courseSelects.size();j++) {
if (students.get(i).studentName.equals(courseSelects.get(j).student.studentName)) {
students.get(i).isHasGrade = true;
if (courseSelects.get(j).score instanceof ExamCourse) { //instanceof判断score中子类类型
students.get(i).studentScore += ((ExamCourse)(courseSelects.get(j).score)).getTotalScore();
cnt++;
} else if (courseSelects.get(j).score instanceof InspectCourse){
students.get(i).studentScore += ((InspectCourse)(courseSelects.get(j).score)).getFinalScore();
cnt++;
}
else if (courseSelects.get(j).score instanceof ExperimentCourse){
students.get(i).studentScore += ((ExperimentCourse)(courseSelects.get(j).score)).getAverageScore();
cnt++;
}
}
}
if (students.get(i).isHasGrade) {
students.get(i).studentScore = students.get(i).studentScore / cnt;
} else {
System.out.println(students.get(i).studentID + " " + students.get(i).studentName+ " did not take any exams");
}
}
Collections.sort(students);//按学号排序
for (int i=0;i < students.size();i++) {
int flag = 0;
for (int j=0;j < courseSelects.size();j++) {
if (students.get(i).studentName.equals(courseSelects.get(j).student.studentName)) {
flag = 1;//参加考试标志
break;
}
}
if (flag == 1) {
System.out.println(students.get(i).studentID + " " + students.get(i).studentName + " " + students.get(i).studentScore);
}
}
}
}
7-2 课程成绩统计程序-3 分数 64 作者 蔡轲 单位 南昌航空大学
课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。
题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩乘以权重后累加而得。
课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。
考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
实验次数至少4次，不超过9次
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
2）学号由8位数字组成
3）姓名不超过10个字符
4）课程名称不超过10个字符
5）不特别输入班级信息，班级号是学号的前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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
输入样例1:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.3
end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet
输入样例2:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2
end
输出样例2:
在这里给出相应的输出。例如：
java : number of scores does not match
输入样例3:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.1
end
输出样例3:
在这里给出相应的输出。例如：
java : weight value error
输入样例4:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end
输出样例4:
在这里给出相应的输出。例如：
20201116 张三 86
java 86
202011 86
输入样例5:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end
输出样例5:
在这里给出相应的输出。例如：
20201116 张三 : access mode mismatch
20201116 张三 did not take any exams
java has no grades yet
202011 has no grades yet
设计思路：
设计类：
课程类（Course）：包括课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重属性，以及保存学生选课成绩的列表属性。
成绩类（Score）：由课程成绩类（CourseScore）和分项成绩类（ItemScore）组成。课程成绩类保存课程总成绩，分项成绩类保存具体分项成绩的值和对应的权重。
学生类（Student）：保存学生的学号、姓名和选课成绩列表。
班级类（Class）：保存班级编号和班级的选课情况。
类之间的关系：
Course 和 Score 之间是组合关系，一个课程有一个课程成绩和多个分项成绩；
Score 和 ItemScore 之间是组合关系，一个成绩包含一个课程成绩和多个分项成绩；
Class 和 Student 之间是聚合关系，一个班级有多个学生；
Course 和 Student 之间是多对多的关系，一个学生可以选择多门课程，一门课程也可以被多个学生选择；
CourseScore 和 Student 之间是聚合关系，一个课程成绩包含多个学生的成绩。
数据结构：
课程列表：用字典实现，key 为课程名称，value 为 Course 对象；
学生列表：用字典实现，key 为学号，value 为 Student 对象；
班级列表：用字典实现，key 为班级编号，value 为 Class 对象。
程序流程：
主要分为以下几个步骤：
解析输入的课程信息、学生成绩信息和实验成绩信息；
根据解析得到的信息创建对应的对象，并保存到相应的列表中；
计算每个学生和课程的总成绩，保存到 Score 对象中；
输出学生、课程和班级的成绩统计结果。
继承和组合关系的区别：
继承是一种 is-a 关系，用于表示子类是父类的一种特殊形式，可以把一些通用的属性和方法提取到父类中，以便子类重用；
组合是一种 has-a 关系，用于表示一个对象包含另一个对象作为其部分，比如一个汽车包含多个轮子。组合关系更加灵活，可以动态组合不同的对象，而不需要考虑它们之间的继承关系。
在本题中，使用组合关系代替继承关系，将课程成绩类与分项成绩类组合在一起，可以更加灵活地管理成绩信息。例如，如果需要添加新的分项成绩，只需要修改分项成绩类，而不需要修改课程成绩类和其他继承自课程成绩类的子类。使用组合关系可以避免多层继承带来的复杂性和耦合度，并使代码更加易于维护。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.stream.Collectors;
class Class {
private String classNum;
HashMap<String , Student> students;
Class(String classNum) {
setClassNum(classNum);
}
public void setClassNum(String classNum) {
this.classNum = classNum;
}
public String getClassNum() {
return classNum;
}
public void addStudent(Student student) {
students.put(student.getStudentNum() , student);
}
}
class Student {
private String name;
private String studentNum;
Student(String name , String studentNum) {
setName(name);
setStudentNum(studentNum);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStudentNum() {
return studentNum;
}
public void setStudentNum(String studentNum) {
this.studentNum = studentNum;
}
}
class Course {
private String className;
private int classQuality;
private int assessmentMethodology;
ArrayList<Float> weightFunction = new ArrayList<>();
Course(String className , int classQuality , int assessmentMethodology) {
setClassName(className);
setClassQuality(classQuality);
setAssessmentMethodology(assessmentMethodology);
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public int getClassQuality() {
return classQuality;
}
public void setClassQuality(int classQuality) {
this.classQuality = classQuality;
}
public int getAssessmentMethodology() {
return assessmentMethodology;
}
public void setAssessmentMethodology(int assessmentMethodology) {
for(int i =0;i<1;i++){}for(int i =0;i<1;i++){}
for(int i =0;i<1;i++){}for(int x =0;x<1;x++){}
this.assessmentMethodology = assessmentMethodology;
}
}
class CourseSelection {
Student student;
Course course;
Grade grade;
}
class Grade {
SubItemGrades subItemGrades = new SubItemGrades();
public int getGrade(){
for(int i =0;i<1;i++){}for(int i =0;i<1;i++){}
float allGrades = 0;for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
for(int i = 0;i<subItemGrades.subItem.size();i++) {
allGrades += subItemGrades.subItem.get(i)*subItemGrades.grades.get(i);
}
return (int) allGrades;
}
}
class SubItemGrades {
ArrayList<Integer> grades = new ArrayList<>();
ArrayList<Float> subItem = new ArrayList<>();
}
class Print {
public void personPrint(HashMap<String , Student> students , ArrayList<CourseSelection> courseSelections) {
Set<String> set = students.keySet();
Object[] arr=set.toArray();
Arrays.sort(arr);
for(Object key:arr) {
int x = 0 , y = 0 , z = -1;
for (CourseSelection courseSelection : courseSelections) {
for(int i =0;i<1;i++){}for(int i =0;i<1;i++){}
for(int i =0;i<1;i++){}
if (students.get(key).getStudentNum().equals(courseSelection.student.getStudentNum())) {
z = 0;
x += courseSelection.grade.getGrade();
y++;
}
}
if(z == -1) {
for(int g =0;g<1;g++){}for(int g =0;g<1;g++){}
System.out.println(students.get(key).getStudentNum()+" "+students.get(key).getName()+" did not take any exams");
}
if(z == 0) {
for(int i =0;i<1;i++){}
x = x / y;
System.out.println(students.get(key).getStudentNum()+" "+students.get(key).getName()+" "+x);
}
}
}
public void coursePrint(HashMap<String , Course> courses , ArrayList<CourseSelection> courseSelections) {
List<String> list = courses.keySet().stream().collect(Collectors.toList());
Collections.sort(list , new SoftName());
for(String key:list) {
for(int i =0;i<1;i++){}
int x = 0 , y = 0 , z = -1;
for (CourseSelection courseSelection : courseSelections) {
for(int g =0;g<1;g++){}for(int g =0;g<1;g++){}
if (courses.get(key).getClassName().equals(courseSelection.course.getClassName())) {
z = 0;
x += courseSelection.grade.getGrade();
y++;
}
}
if(z == -1) {
for(int g =0;g<1;g++){}for(int g =0;g<1;g++){}
System.out.println(courses.get(key).getClassName()+" has no grades yet");
}
if(z == 0) {
for(int i =0;i<1;i++){}
x = x/y;
System.out.println(courses.get(key).getClassName()+" "+x);
}
}
}
public void classPrint(HashMap<String , Class> classes , ArrayList<CourseSelection> courseSelections) {
Set<String> set = classes.keySet();
Object[] arr=set.toArray();
Arrays.sort(arr);
for(Object key:arr) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
for(int i =0;i<1;i++){}
int x = 0 , y = 0 , z = -1;
for(CourseSelection courseSelection : courseSelections) {
if(classes.get(key).students.containsKey(courseSelection.student.getStudentNum())) {
z = 0;
x += courseSelection.grade.getGrade();
y++;
}
}
if(z == -1) {
for(int g =0;g<1;g++){}for(int g =0;g<1;g++){}
System.out.println(classes.get(key).getClassNum()+" has no grades yet");
}
if(z == 0) {
for(int g =0;g<1;g++){}
x = x/y;
System.out.println(classes.get(key).getClassNum()+" "+x);
}
}
}
public void wrongFormat() {
System.out.println("wrong format");
}
public void courseExist(String name) {
for(int i =0;i<1;i++){}for(int x =0;x<1;x++){}
System.out.println(name+" does not exist");
}
public void courseMatch(String studentNum , String studentName) {
System.out.println(studentNum+" "+studentName+" : access mode mismatch");
}
public void courseMatch(String name) {
for(int i =0;i<1;i++){}for(int x =0;x<1;x++){}
System.out.println(name+" : course type & access mode mismatch");
}
public void numMatch(String name) {
System.out.println(name+" : number of scores does not match");
}
public void weightValue(String name) {
System.out.println(name+" : weight value error");
}
static class SoftName implements Comparator<String>{
public int compare(String name1 , String name2) {
for(int i =0;i<1;i++){}for(int i =0;i<1;i++){}
Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
return compare.compare(name1 , name2);
}
}
}
class Dish {
String name;//菜品名称
int unit_price;
int getPrice(int portion) {
int peic = 0;
if (portion == 1) {
peic = unit_price ;
} else if (portion == 2) {
peic = Math.round((float) (unit_price * 1.5)) ;
} else if (portion == 3) {
peic = (unit_price * 2) ;
}
return peic;
}
}
class Menu {
Dish[] dishs = new Dish[10];
int count = 0;
Dish searthDish(String dishName){
Dish temd = null;
for(int i=count-1;i>=0;i--){
if(dishName.equals(dishs[i].name)){
temd = dishs[i];
break;
}
}
if(temd==null){
System.out.println(dishName+" does not exist");
}
return temd;
}
Dish addDish(String dishName,int unit_price){
Dish dh = new Dish();
dh.name = dishName;
dh.unit_price = unit_price;
count++;
return dh;
}//添加一道菜品信息
}
class Record {
int orderNum;//序号\
//int AntherOrderNum;
Dish d = new Dish();//菜品\
int num = 0;
int portion;//份额（1/2/3代表小/中/大份）\
//int exist = 1;
int getPrice(){
return d.getPrice(portion)*num;
}//计价，计算本条记录的价格\
}
class Order {
Record[] records = new Record[10];//保存订单上每一道的记录
int count = 0;//订单数量
void addARecord(int orderNum,String dishName,int portion,int num){
records[count] = new Record();
records[count].d.name = dishName;
records[count].orderNum = orderNum;
records[count].portion = portion;
records[count].num = num;
count++;
}//添加一条菜品信息到订单中。
int delARecordByOrderNum(int orderNum){
if(orderNum>count||orderNum<=0){
System.out.println("delete error;");
return 0;
}else {
return records[orderNum - 1].getPrice();
}
}//根据序号删除一条记录
}
class Table {
int tableNum;
String tableDtime;
int year,month,day,week,hh,mm,ss;
int sum = 0;//一桌价格 ；
// boolean f = true;
Order odt = new Order();
//Order odre = new Order();
float discnt = -1;
void Gettottalprice(){
if(discnt>0){
sum = Math.round(sum*discnt);
System.out.println("table " + tableNum + ": " + sum);
}else {
System.out.println("table " + tableNum + " out of opening hours");
}
}
void AheadProcess(String tableDtime){
this.tableDtime = tableDtime;
processTime();
discount();
}
void processTime(){//处理时间
String[] temp = tableDtime.split(" ");
tableNum = Integer.parseInt(temp[1]);
String[] temp1 = temp[2].split("/");
String[] temp2 = temp[3].split("/");
year = Integer.parseInt(temp1[0]);
month = Integer.parseInt(temp1[1]);
day = Integer.parseInt(temp1[2]);
Calendar c = Calendar.getInstance();
c.set(year, (month-1), day);
week = c.get(Calendar.DAY_OF_WEEK);
if(week==1)
week = 7;
else
week--;
hh = Integer.parseInt(temp2[0]);
mm = Integer.parseInt(temp2[1]);
ss = Integer.parseInt(temp2[2]);
}
//void CheckAtime(){
// f= !(discnt < 0);
// }
void discount(){
if(week>=1&&week<=5)
{
if(hh>=17&&hh<20)
discnt=0.8F;
else if(hh==20&&mm<30)
discnt=0.8F;
else if(hh==20&&mm==30&&ss==0)
discnt=0.8F;
else if(hh>=11&&hh<=13||hh==10&&mm>=30)
discnt=0.6F;
else if(hh==14&&mm<30)
discnt=0.6F;
else if(hh==14&&mm==30&&ss==0)
discnt=0.6F;
}
else
{
if(hh>=10&&hh<=20)
discnt= 1.0F;
else if(hh==9&&mm>=30)
discnt= 1.0F;
else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
discnt= 1.0F;
}
}
}
class MessageGetAndPrint {
Print print;
HashMap<String , Class> classes = new HashMap<>();
HashMap<String , Student> students = new HashMap<>();
HashMap<String , Course> courses = new HashMap<>();
ArrayList<CourseSelection> courseSelections = new ArrayList<>();
public void getMessage(String getInput) {
for(int i =0;i<1;i++){}for(int i =0;i<1;i++){}
String[] message = getInput.split(" ");
if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$") ||
getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )((0.(0)+[1-9]|0.[1-9][0-9]*)( )(0.(0)+[1-9]|0.[1-9][0-9]*)$)") ||
getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )([4-9])((( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))*)(( )(0.(0)+[1-9]|0.[1-9][0-9]*))$")
) {
if(courses.containsKey(message[0])) {
return;
}
int i = 0, j = 0;
if(message[1].equals("必修")) {
for(int x =0;x<1;x++){}
i = 1;
}
if(message[1].equals("选修")) {
for(int x =0;x<1;x++){}
i = 2;
}
if(message[1].equals("实验")) {
for(int x =0;x<1;x++){}
i = 3;
}
if(message[2].equals("考试")) {
for(int x =0;x<1;x++){}
j = 1;
}
if(message[2].equals("考察")) {
for(int x =0;x<1;x++){}
j = 2;
}
if(message[2].equals("实验")) {
for(int x =0;x<1;x++){}
j = 3;
}
if((i == 1 && j != 1) || (i == 3 && j != 3) || (i != 3 && j == 3) ) {
for(int x =0;x<1;x++){}
print.courseMatch(message[0]);
return;
}
if((j == 1 && message.length != 5) || (j == 2 && message.length != 3) || (j == 3 && message.length - 4 != Integer.parseInt(message[3]))) {
print.numMatch(message[0]);
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
return;
}
if(j == 1 && Float.parseFloat(message[3])+Float.parseFloat(message[4]) != 1) {
for(int x =0;x<1;x++){}
print.weightValue(message[0]);
return;
}
if(j == 3) {
for(int x =0;x<1;x++){}
float value = 0;
for(int k = 0 ; k < Integer.parseInt(message[3]) ; k++) {
value += Float.parseFloat(message[4+k]);
}
if(value>1.001||value<0.999) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
print.weightValue(message[0]);
return;
}
}
Course course = new Course(message[0], i, j);
if(j == 1) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
course.weightFunction.add(Float.parseFloat(message[3]));
course.weightFunction.add(Float.parseFloat(message[4]));
}
if(j == 2)
course.weightFunction.add(1F);
if(j == 3) {
for(int x =0;x<1;x++){}
for(int k = 0 ; k < Integer.parseInt(message[3]) ; k++) {
for(int x =0;x<1;x++){}
course.weightFunction.add(Float.parseFloat(message[4+k]));
}
}
courses.put(message[0], course);
}
else if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)$") ||
getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$") ||
getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )((([0-9]|[1-9][0-9]|100)( ))*)([0-9]|[1-9][0-9]|100)$")
) {
for(CourseSelection courseSelection:courseSelections) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
return;
}
}
Student student = new Student(message[1], message[0]);
for(int g =0;g<1;g++){}for(int g =0;g<1;g++){}
students.put(message[0] , student);
String classNum = message[0].substring(0 , 6);
if(!classes.containsKey(classNum)) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
Class aClass = new Class(classNum);
classes.put(classNum , aClass);
classes.get(classNum).students = new HashMap<>();
}
classes.get(classNum).addStudent(student);
if(!courses.containsKey(message[2])) {
for(int x =0;x<1;x++){}
print.courseExist(message[2]);
return;
}
if(message.length - 3 != courses.get(message[2]).weightFunction.size()) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
print.courseMatch(message[0] , message[1]);
return;
}
CourseSelection courseSelection = new CourseSelection();
courseSelection.student = student;
courseSelection.course = courses.get(message[2]);
Grade grade = new Grade();
for(int g =0;g<1;g++){}for(int g =0;g<1;g++){}
for(int i = 0 ; i < message.length - 3 ; i++) {
for(int x =0;x<1;x++){}for(int x =0;x<1;x++){}
grade.subItemGrades.grades.add(Integer.parseInt(message[3+i]));
}
grade.subItemGrades.subItem = courses.get(message[2]).weightFunction;
for(int g =0;g<1;g++){}
courseSelection.grade = grade;
courseSelections.add(courseSelection);
}
else
for(int g =0;g<1;g++){
print.wrongFormat();
}
}
}
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
messageGetAndPrint.print = new Print();
Menu menu = new Menu();
Table[] tablemes = new Table[10];
String dishName = "a";
int unit_price = 0;
Dish dish = null;
int orderId, quantity, price;
orderId = Integer.parseInt("12");
quantity = Integer.parseInt("12");
price = Integer.parseInt("12");
menu.addDish(dishName,unit_price);
tablemes.clone();
for(;;){
String message = in.readLine();
if(message.equals("end")) {
for(int i =0;i<1;i++){}for(int i =0;i<1;i++){}
for(int i =0;i<1;i++){}
messageGetAndPrint.print.personPrint(messageGetAndPrint.students , messageGetAndPrint.courseSelections);
messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses , messageGetAndPrint.courseSelections);
messageGetAndPrint.print.classPrint(messageGetAndPrint.classes , messageGetAndPrint.courseSelections);
break;
}
messageGetAndPrint.getMessage(message);
}
}
}
（3）采坑心得：
在处理成绩信息时，务必检查课程名称是否在已输入的课程列表中。如果不在列表中，则需要及时输出错误信息以提醒用户。此外，还应该验证输入的成绩数量和课程的考核方式是否匹配，若不匹配也需要给出相应的错误提示。
另外，在解析课程信息时，需要验证输入的课程性质和考核方式是否匹配，如果不匹配同样需要输出错误信息。而在处理实验课程信息时，要检查输入的分项成绩数量值和分项成绩权重的个数是否匹配，以避免出现错误。
在解析考试课和实验课时，还需检查分项成绩权重值的总和是否等于1，若不等于1也需要进行错误提示。
另外，在计算成绩时，也应该谨慎检查成绩是否超出范围，如果超出范围同样需要输出错误信息。
为避免因格式错误导致输出错误，应该仔细阅读题目要求，并按照指定的格式输入信息。对于输入的成绩信息，也需进行合法性检查，确保成绩在允许的范围内。
为了避免重复处理造成的错误，可以通过建立一个课程或成绩信息的集合来判断是否重复。此外，在编写代码时，将不同的功能模块封装成函数或方法能够方便代码的重用和维护。
最后，在处理异常情况时，可以使用异常处理机制来捕获和处理异常，提高程序的健壮性
（4）改进建议：将计算分数的方式进行修改，例如课程成绩统计程序-3可以把其中计算分数的方法去掉放在主方法中，这样能更为方便的去处理学生个数的问题，而且不必传入过多的参数。
（5）总结：通过本次题目集的完成，我对面向对象设计的三大原则有了更深入的理解，并在个人设计能力上得到了训练。首先，单一职责原则要求每个类只负责完成一个单一的职责或功能，使得类的设计更加清晰和简洁。在课程成绩统计程序-1升级到课程成绩统计程序-2时，只需要修改Course类，这体现了单一职责原则的应用。
其次，开放封闭原则指出软件实体应对扩展是开放的，对修改是封闭的。换言之，当实体的行为需要修改时，应通过扩展新的代码来实现，而不是修改原有的代码。这样可以保持代码的稳定性。在本次题目集中，我们遵循了开放封闭原则，通过创建新的类和方法来扩展功能，而不是直接修改已有的代码。
最后，里氏替换原则要求子类能够替换其父类并保持原有的行为，实现代码的扩展和复用。在课程成绩统计程序-1中，我们使用了Score的两个子类ExamScore和InspectScore。通过遵循里氏替换原则，我们能够灵活地使用子类对象替换父类对象，而不会破坏原有代码的逻辑。
熟悉并遵循这些面向对象设计原则可以使代码更加灵活、可扩展和易于理解，从而提高软件的可靠性和可维护性。通过本次题目集的实践，我不仅更深入地理解了这些原则，还在个人设计能力上得到了锻炼。
import java.text.Collator;import java.util.*;
public class Main { public static void main(String[] args) {
ArrayList<CourseSelect> courseSelects = new ArrayList<>(); ArrayList<Course> courses = new ArrayList<>(); ArrayList<Student> students = new ArrayList<>(); ArrayList<Class> classes = new ArrayList<>();
Scanner in =new Scanner(System.in); String input = in.nextLine(); while (!input.equals("end")) { String[] buff = input.split(" "); if (input.matches("[\\u4e00-\\u9fa5a-zA-Z]{1,10} (必修|选修|实验) (考试|考察|实验)")) {//输入的是课程信息 if (buff[1].equals("必修") && buff[2].equals("考察")||buff[1].equals("必修") && buff[2].equals("实验")||buff[1].equals("选修") && buff[2].equals("实验")) { //课程性质和课程的考核方式不匹配 System.out.println(buff[0] + " : course type & access mode mismatch"); } else{ int isSame = 0; for (int i=0;i < courses.size();i++) { if (courses.get(i).courseName.equals(buff[0])) { isSame = 1;//输入重复的课程 break; } } if (isSame == 0) { Course course = new Course(); course.courseName = buff[0]; course.courseType = buff[1]; course.courseMethod = buff[2]; courses.add(course); } } } else if (input.matches("\\d{8} [\\u4e00-\\u9fa5a-zA-Z]{1,10} [\\u4e00-\\u9fa5a-zA-Z]{1,10} ([4-9])( ([0-9]|[1-9][0-9]|100))*") || input.matches("\\d{8} [\\u4e00-\\u9fa5a-zA-Z]{1,10} [\\u4e00-\\u9fa5a-zA-Z]{1,10} ([0-9]|[1-9][0-9]|100)( ([0-9]|[1-9][0-9]|100))?")) {//输入的是选课 int cnt = 0; for (int i = 0; i < courses.size(); i++) { if (courses.get(i).courseName.equals(buff[2])) { i = cnt; } else{ cnt = -1; } } if (courses.isEmpty()) { System.out.println(buff[2] + " does not exist"); } else { //有这门课 if(cnt != -1) { int i = cnt; //输入的成绩数量和课程的考核方式不匹配 if ((courses.get(i).courseMethod.equals("考试") && buff.length != 5) || (courses.get(i).courseMethod.equals("考察") && buff.length != 4)|| (courses.get(i).courseMethod.equals("实验") && Integer.parseInt(buff[3]) != buff.length - 4)) { System.out.println(buff[0] + " " + buff[1] + " : access mode mismatch"); } else { CourseSelect courseSelect = new CourseSelect(); Course course = new Course(); Student student = new Student();
//课程 course.courseName= buff[2]; courseSelect.course = course; //学生 student.studentID= buff[0]; student.studentName= buff[1]; courseSelect.student = student;
//考试 if (buff.length == 5) { ExamCourse exam = new ExamCourse(); exam.dailyScore = Integer.parseInt(buff[3]); exam.finalScore = Integer.parseInt(buff[4]); courseSelect.score = exam; } //考察 else if (buff.length == 4) { InspectCourse inspect = new InspectCourse(); inspect.finalScore = Integer.parseInt(buff[3]); courseSelect.score = inspect; } else { int sum = 0; ExperimentCourse experiment = new ExperimentCourse(); for (int j = 4;j < buff.length;j++) { sum += Integer.parseInt(buff[j]); } sum = sum / (buff.length - 4); experiment.averageScore = sum; courseSelect.score = experiment; } courseSelects.add(courseSelect); } } else {//课程信息没有这门课 System.out.println(buff[2] + " does not exist"); } } // 学生信息与班级防止重复 //录入学生信息 int isSameStudent = 0; for (int j=0;j < students.size();j++) { if (students.get(j).studentID.equals(buff[0])) { isSameStudent = 1; break; } } if (isSameStudent == 0) { Student student = new Student(); student.studentID = buff[0]; student.studentName= buff[1]; students.add(student); } //录入班级信息 int isSameClass = 0; for (int k=0;k < classes.size();k++) { if (classes.get(k).className.equals(buff[0].substring(0, 6))) { isSameClass = 1; break; } } if (isSameClass == 0) { Class Classes = new Class(); Classes.className = buff[0].substring(0,6); classes.add(Classes); } } else { System.out.println("wrong format"); } input = in.nextLine();
} Student student = new Student(); Course course = new Course(); Class class1 = new Class(); student.showStudentScore(students,courseSelects); course.showCourseScore(courses,courseSelects); class1.showClassScore(classes,students);
}}class Class implements Comparable<Class> { String className; int classScore; public String getClassName() { return className; }
public Class() { }
@Override public int compareTo(Class o) { return this.getClassName().compareTo(o.getClassName()); }
public void showClassScore(ArrayList<Class>classes,ArrayList<Student>students){ for (int i=0;i < classes.size();i++) {//计算班级成绩 int cnt = 0; int flag = 0; for (int j=0;j < students.size();j++) { if (classes.get(i).className.equals(students.get(j).studentID.substring(0,6)) && students.get(j).isHasGrade) {//是这个班级的学生且有成绩 flag = 1; classes.get(i).classScore += students.get(j).studentScore; cnt++; } } if (flag == 1) { classes.get(i).classScore = classes.get(i).classScore / cnt; } else{ System.out.println(classes.get(i).className+ " has no grades yet"); } }
Collections.sort(classes);//班级排序 for (int i=0;i < classes.size();i++) { int flag = 0; for (int j=0;j < students.size();j++) { if (classes.get(i).className.equals(students.get(j).studentID.substring(0,6)) && students.get(j).isHasGrade) {//是这个班级的学生 flag = 1; } } if (flag == 1) { System.out.println(classes.get(i).className + " " + classes.get(i).classScore); } } }}class Course { String courseName; String courseType; String courseMethod; int dailyAverage; int testAverage; int totalScore; public String getName() { return courseName; }
public Course() { }
public void showCourseScore(ArrayList<Course> courses, ArrayList<CourseSelect>courseSelects){ //计算课程成绩 for (int i=0;i < courses.size();i++) { int cntExam = 0; int cntInspect = 0; int cntExperiment = 0; int flag = 0; for (int j=0;j < courseSelects.size();j++) { if (courses.get(i).courseName.equals(courseSelects.get(j).course.courseName)) { flag = 1; if (courseSelects.get(j).score instanceof ExamCourse) { //考试 courses.get(i).dailyAverage += ((ExamCourse)courseSelects.get(j).score).getDailyScore(); courses.get(i).testAverage += ((ExamCourse)courseSelects.get(j).score).getFinalScore(); courses.get(i).totalScore += ((ExamCourse)courseSelects.get(j).score).getTotalScore(); cntExam++; } else if (courseSelects.get(j).score instanceof InspectCourse) { //考察 courses.get(i).testAverage += ((InspectCourse)courseSelects.get(j).score).getFinalScore(); courses.get(i).totalScore += ((InspectCourse)courseSelects.get(j).score).getFinalScore(); cntInspect++; } else if (courseSelects.get(j).score instanceof ExperimentCourse) { //考察 courses.get(i).testAverage += ((ExperimentCourse)courseSelects.get(j).score).getAverageScore(); courses.get(i).totalScore += ((ExperimentCourse)courseSelects.get(j).score).getAverageScore(); cntExperiment++; } } } if (flag == 1) { if (courses.get(i).courseMethod.equals("考试")) { courses.get(i).dailyAverage = courses.get(i).dailyAverage / cntExam; courses.get(i).testAverage = courses.get(i).testAverage / cntExam; courses.get(i).totalScore = courses.get(i).totalScore / cntExam; } else if (courses.get(i).courseMethod.equals("考察")) { courses.get(i).testAverage= courses.get(i).testAverage / cntInspect; courses.get(i).totalScore = courses.get(i).totalScore / cntInspect; } else if (courses.get(i).courseMethod.equals("实验")) { courses.get(i).testAverage = courses.get(i).testAverage / cntExperiment; courses.get(i).totalScore = courses.get(i).totalScore / cntExperiment; } } else{ System.out.println(courses.get(i).courseName + " has no grades yet"); } }
//Course排序 Comparator<Course> comparator = new Comparator<>() { Collator collator = Collator.getInstance(Locale.CHINA);
@Override public int compare(Course o1, Course o2) { return collator.compare(o1.getName(), o2.getName()); } }; Collections.sort(courses, comparator); for (int i=0;i < courses.size();i++) { int isHasScore = 0; for (int j=0;j < courseSelects.size();j++) { if (courses.get(i).courseName.equals(courseSelects.get(j).course.courseName)) { isHasScore = 1; break; } } if (isHasScore == 1) { if (courses.get(i).courseMethod.equals("考试")) { System.out.println(courses.get(i).courseName + " " + courses.get(i).dailyAverage + " " + courses.get(i).testAverage + " " + courses.get(i).totalScore); } else if (courses.get(i).courseMethod.equals("考察")) { System.out.println(courses.get(i).courseName + " " + courses.get(i).testAverage + " " + courses.get(i).totalScore); } else if (courses.get(i).courseMethod.equals("实验")) { System.out.println(courses.get(i).courseName+ " " + courses.get(i).totalScore); } } } }}class CourseSelect { Course course; Student student; Score score;
public CourseSelect() { }}class ExamCourse extends Score { int dailyScore; int finalScore;
public ExamCourse() { }
public int getDailyScore() { return dailyScore; } public int getFinalScore() { return finalScore; } public int getTotalScore() { return (int) (dailyScore * 0.3 + finalScore * 0.7); }}class InspectCourse extends Score { int finalScore; public int getFinalScore() { return finalScore; }
public InspectCourse() { }}class Dish { String name;//菜品名称 int unit_price; //单价//int num;
int getPrice(int portion) { int peic = 0; if (portion == 1) { peic = unit_price ; } else if (portion == 2) { peic = Math.round((float) (unit_price * 1.5)) ; } else if (portion == 3) { peic = (unit_price * 2) ; } return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }}class Menu { Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息 int count = 0;
Dish searthDish(String dishName){ Dish temd = null; for(int i=count-1;i>=0;i--){ if(dishName.equals(dishs[i].name)){ temd = dishs[i]; break; } } if(temd==null){ System.out.println(dishName+" does not exist"); } return temd; }//根据菜名在菜谱中查找菜品信息，返回Dish对象。 Dish addDish(String dishName,int unit_price){ Dish dh = new Dish(); dh.name = dishName; dh.unit_price = unit_price; count++; return dh; }//添加一道菜品信息}class Record { int orderNum;//序号\ //int AntherOrderNum; Dish d = new Dish();//菜品\ int num = 0; int portion;//份额（1/2/3代表小/中/大份）\ //int exist = 1; int getPrice(){ return d.getPrice(portion)*num; }//计价，计算本条记录的价格\}class Order { Record[] records = new Record[10];//保存订单上每一道的记录 int count = 0;//订单数量
void addARecord(int orderNum,String dishName,int portion,int num){ records[count] = new Record(); records[count].d.name = dishName; records[count].orderNum = orderNum; records[count].portion = portion; records[count].num = num; count++; }//添加一条菜品信息到订单中。
int delARecordByOrderNum(int orderNum){ if(orderNum>count||orderNum<=0){ System.out.println("delete error;"); return 0; }else { return records[orderNum - 1].getPrice(); } }//根据序号删除一条记录}class Table { int tableNum; String tableDtime; int year,month,day,week,hh,mm,ss; int sum = 0;//一桌价格 ； // boolean f = true; Order odt = new Order(); //Order odre = new Order(); float discnt = -1; void Gettottalprice(){ if(discnt>0){ sum = Math.round(sum*discnt); System.out.println("table " + tableNum + ": " + sum); }else { System.out.println("table " + tableNum + " out of opening hours"); } } void AheadProcess(String tableDtime){ this.tableDtime = tableDtime; processTime(); discount(); }
void processTime(){//处理时间 String[] temp = tableDtime.split(" "); tableNum = Integer.parseInt(temp[1]); String[] temp1 = temp[2].split("/"); String[] temp2 = temp[3].split("/");
year = Integer.parseInt(temp1[0]); month = Integer.parseInt(temp1[1]); day = Integer.parseInt(temp1[2]);
Calendar c = Calendar.getInstance(); c.set(year, (month-1), day); week = c.get(Calendar.DAY_OF_WEEK); if(week==1) week = 7; else week--; hh = Integer.parseInt(temp2[0]); mm = Integer.parseInt(temp2[1]); ss = Integer.parseInt(temp2[2]);
} //void CheckAtime(){// f= !(discnt < 0);// } void discount(){ if(week>=1&&week<=5) { if(hh>=17&&hh<20) discnt=0.8F; else if(hh==20&&mm<30) discnt=0.8F; else if(hh==20&&mm==30&&ss==0) discnt=0.8F; else if(hh>=11&&hh<=13||hh==10&&mm>=30) discnt=0.6F; else if(hh==14&&mm<30) discnt=0.6F; else if(hh==14&&mm==30&&ss==0) discnt=0.6F; } else { if(hh>=10&&hh<=20) discnt= 1.0F; else if(hh==9&&mm>=30) discnt= 1.0F; else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0) discnt= 1.0F; } }}
class ExperimentCourse extends Score{
int[] daily = new int[10]; int averageScore; int totalScore;
public ExperimentCourse() { }
public int[] getDaily() { return daily; }
public int getTotalScore() { return totalScore; }
public int getAverageScore() { return averageScore; }}abstract class Score { public Score() { }}class Student implements Comparable<Student> { String studentID; String studentName; int studentScore; boolean isHasGrade = false;
public Student() { }
public String getStudentID() { return studentID; }
@Override public int compareTo(Student o) { return this.getStudentID().compareTo(o.getStudentID()) ; }
public void showStudentScore(ArrayList<Student>students,ArrayList<CourseSelect>courseSelects){ for (int i=0;i < students.size();i++) { //计算每个学生的总成绩 int cnt = 0; for (int j=0;j < courseSelects.size();j++) { if (students.get(i).studentName.equals(courseSelects.get(j).student.studentName)) { students.get(i).isHasGrade = true; if (courseSelects.get(j).score instanceof ExamCourse) { //instanceof判断score中子类类型 students.get(i).studentScore += ((ExamCourse)(courseSelects.get(j).score)).getTotalScore(); cnt++; } else if (courseSelects.get(j).score instanceof InspectCourse){ students.get(i).studentScore += ((InspectCourse)(courseSelects.get(j).score)).getFinalScore(); cnt++; } else if (courseSelects.get(j).score instanceof ExperimentCourse){ students.get(i).studentScore += ((ExperimentCourse)(courseSelects.get(j).score)).getAverageScore(); cnt++; } } } if (students.get(i).isHasGrade) { students.get(i).studentScore = students.get(i).studentScore / cnt; } else { System.out.println(students.get(i).studentID + " " + students.get(i).studentName+ " did not take any exams"); } }
Collections.sort(students);//按学号排序 for (int i=0;i < students.size();i++) { int flag = 0; for (int j=0;j < courseSelects.size();j++) { if (students.get(i).studentName.equals(courseSelects.get(j).student.studentName)) { flag = 1;//参加考试标志 break; } } if (flag == 1) { System.out.println(students.get(i).studentID + " " + students.get(i).studentName + " " + students.get(i).studentScore); } } }} 标签：get,int,Blog,courses,课程,成绩,buff From： https://www.cnblogs.com/yiran881616/p/17881068.html