一、前言
终于是没有pta作业了，这两次的pta主要的成绩题目，再写完菜单后再来写这两次pta还算比较ok。至少不像之前那么痛苦。题目也不难，主要就是用继承和多态用的比较多，还有就是组合在成绩3题目中。
二、设计和分析
PTA作业7
分析：
7-1 容器-HashMap-检索和7-2 容器-HashMap-排序主要实现HashMap存储学生信息，并实现检索和排序功能。在Java中，HashMap是一种常用的集合类，用于存储键值对。它实现了Map接口，并基于哈希表的数据结构。HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。
7-4 动物发声模拟器（多态）：很明显的抽象类然后重写其方法实现多态，只要知道java中继承和抽象类，还有重写父类方法就能写出来。
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
分析：成绩1是在第三次PTA作业中，那时候对java还不是特别熟悉，特别是如何处理类之间的关系，还有设计上很多都不熟悉或者说对如何设计类不知道怎么下手，遇到一些复杂的情况，不会处理，所以没有写出来。当经过一段时间的学习后加上写过菜单等一系列题目。再回头去看成绩题目，再去写就已经没那么难。特别是在学过java中的几种关系模式，对继承，封装还有多态的理解也更深入，写起来就跟轻松。成绩2相比成绩1多增加实验课的处理，因为有3种不同的成绩信息，所以写了一个抽象成绩类，通过继承来分别实现其他成绩信息。具体类实现在下面类图中。
类图：
代码：
import java.util.*;
//课程成绩统计程序-2
abstract class Grade{
abstract int totalGrade();
//成绩的取值范围是【0,100】
abstract boolean isGrade();
}
class ExamGrade extends Grade{
int usualGrades;
int finalGrades;
ExamGrade(){
}
ExamGrade(int usualGrades,int finalGrades){
this.usualGrades=usualGrades;
this.finalGrades=finalGrades;
}
int totalGrade() {//考试总成绩=平时成绩*0.3+期末成绩*0.7。
return (int)(0.3*usualGrades+0.7*finalGrades);
}
int getUsaualGrade() {
return usualGrades;
}
int getFinalGrade() {
return finalGrades;
}
boolean isGrade() {
if(usualGrades>=0&&usualGrades<=100&&finalGrades>=0&&finalGrades<=100) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
}
class InspectGrade extends Grade{
int finalGrades;
InspectGrade(){
}
InspectGrade(int finalGrades){
this.finalGrades=finalGrades;
}
int getFinalGrade() {
return finalGrades;
}
int totalGrade() {//考察的总成绩直接等于期末成绩
return finalGrades;
}
boolean isGrade() {
if(finalGrades>=0&&finalGrades<=100) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
}
class ExperimentGrade extends Grade{ //实验成绩
int times; //实验次数
int [] grades;
ExperimentGrade(){
}
ExperimentGrade(int times,int [] grades){
this.times=times;
this.grades=grades;
}
int totalGrade() {//实验的总成绩等于课程每次实验成绩的平均分
int sum=0;
for(int i=0;i<times;i++) {
sum+=grades[i];
}
return sum/times;
}
//实验次数判断，实验次数至少4次，不超过9次
boolean isTimes() {
if(times<4||times>9) {
System.out.println("wrong format");
return false;
}
else {
return true;
}
}
boolean isGrade() {
int flag=1;
for(int n:grades) {
if(n<0||n>100) {
flag=0;
}
}
if(flag==1) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
}
class Course{ //课程
String courseName;
String courseNature;//课程性质,必修课、选修课、实验课
String courseAssess;//考核方式,考试、考察、实验
public Course(String courseName,String courseNature,String courseAssess) {
this.courseName=courseName;
this.courseNature=courseNature;
this.courseAssess=courseAssess;
}
public Course(String courseName) {
this.courseName=courseName;
}
public String getCourseName() {
return courseName;
}
public String getCourseNature() {//得到课程性质,必修课、选修课、实验课
return courseNature;
}
public String getCourseAssess() {//得到考核方式
return courseAssess;
}
//3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，
//输出：课程名称+" : course type & access mode mismatch"
public boolean isCourse() {
if(courseNature.equals("必修")&&courseAssess.equals("考试")) {
return true;
}
else if(courseNature.equals("选修")&&(courseAssess.equals("考试")||courseAssess.equals("考察"))) {
return true;
}
else if(courseNature.equals("实验")&&courseAssess.equals("实验")) {
return true;
}
else {
System.out.println(courseName+" : course type & access mode mismatch");
return false;
}
}
//课程名称不超过10个字符
public boolean iscourseName() {
if(courseName.matches(".{1,10}")) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
public boolean isFindCourse(List<Course> courseList) {//是否有相同课程
for(Course cou:courseList) {
if(courseName.equals(cou.getCourseName())) {
return false;
}
}
return true;
}
//总成绩平均分
void printCourseGrade(List<CourseSelect> courSeList) {
int usualScorce=0;
int finalScorce=0;
int sum=0;
int number=0;
int flag=1;
ExamGrade exGrade=new ExamGrade();
InspectGrade inGrade=new InspectGrade();
ExperimentGrade exPGrade=new ExperimentGrade();
for(CourseSelect cous:courSeList) {
if(cous.grade!=null) {
if(courseAssess.equals("考试")) {
if(courseName.equals(cous.course.courseName)&&cous.grade instanceof ExamGrade) {
exGrade=(ExamGrade) cous.grade;
usualScorce+=exGrade.getUsaualGrade();
finalScorce+=exGrade.getFinalGrade();
sum+=cous.getTotalGrade();
number++;
}
}
else if(courseAssess.equals("考察")) {
if(courseName.equals(cous.course.courseName)) {
inGrade=(InspectGrade) cous.grade;
finalScorce+=inGrade.getFinalGrade();
sum+=cous.getTotalGrade();
number++;
}
}
else if(courseAssess.equals("实验")) {
if(courseName.equals(cous.course.courseName)) {
exPGrade=(ExperimentGrade) cous.grade;
sum+=cous.getTotalGrade();
number++;
}
}
}
else {
flag=0;
}
}//for()
if(number!=0) {
if(courseAssess.equals("考试")) {
System.out.println(courseName+" "+usualScorce/number+" "+finalScorce/number+" "+sum/number);
}
else if(courseAssess.equals("考察")) {
System.out.println(courseName+" "+finalScorce/number+" "+sum/number);
}
else if(courseAssess.equals("实验")) {
System.out.println(courseName+" "+sum/number);
}
}
else {//课程名称+英文空格+"has no grades yet"
System.out.println(courseName+" has no grades yet");
}
}
}
class Student{ //学生
String num;
String name;
Grade grade;
public Student(String num,String name,Grade grade) {
this.num=num;
this.name=name;
}
public String getNum() {
return num;
}
//学号由8位数字组成
boolean isNum() {
if(num.matches("[0-9]{8}")) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
//姓名不超过10个字符
boolean isName() {
if(name.matches(".{1,10}")) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
String getClassID() {
return num.substring(0,6);
}
int getTotalGrade() {
return grade.totalGrade();
}
}
class Class{ //班级
String classID;
//int number;
//List<Student> students;
Class(String num){
this.classID=num.substring(0,6);
}
String getClassID() {
return classID;
}
boolean isFindClass(List<Class> classList) {
//int flag=1;
for(Class cla:classList) {
if(classID.equals(cla.classID)) {
//flag=0;
return false;
}
}
return true;
}
void classGrade(List<CourseSelect> courSeList) {
int sum=0;
int number=0;
int flag=1;
for(CourseSelect cous:courSeList) {
if(cous.grade!=null) {
if(classID.equals(cous.student.getClassID())) {
sum+=cous.getTotalGrade();
number++;
}
}
else {
flag=0;
}
}
if(number==0) {
System.out.println(classID+" "+"has no grades yet");
}
else {
System.out.println(classID+" "+sum/number);
}
//return sum/number;
}
}
//考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
//实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
class CourseSelect{//选课
Course course;
Student student;
Grade grade;
public CourseSelect(Course course,Student student,Grade grade) {
this.course = course;
this.student=student;
this.grade=grade;
}
public String getStudentNum() {
return student.getNum();
}
//如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
public boolean isCourseGrade() {
if(grade!=null) {
return true;
}
else {
System.out.println(course.courseName+" has no grades yet");
return false;
}
}
//1）学生课程总成绩平均分按学号由低到高排序输出
//格式：学号+英文空格+姓名+英文空格+总成绩平均分
//如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
int getTotalGrade() {
return grade.totalGrade();
}
void printStuGrade() {
if(grade!=null) {
System.out.println(student.num+" "+student.name+" "+getTotalGrade());
}
else {
System.out.println(student.num+" "+student.name+" did not take any exams");
}
}
//2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
//考试/考察课程成绩格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
//1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，
//输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
boolean isCourseExist(List<Course> courseList) {
int flag=0;
for(Course cour:courseList) {
if(course.courseName.equals(cour.courseName)) {
course=cour;
flag=1;
}
}
if(flag==1) {
return true;
}
else {
System.out.println(course.courseName+" does not exist");
//System.out.println(student.num+" "+student.name+" :"+course.courseName+" does not exist");
return false;
}
}
}
public class Main {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
List<CourseSelect> courSeList=new ArrayList <>();//选课记录
List<Student> studentList=new ArrayList <>();
List<Course> courList=new ArrayList <>();//课程记录
List<Class> classList=new ArrayList<>();//班级记录
while(true) {
String inputStr=input.nextLine();
if(inputStr.equals("end")) {
break;
}
String []strs=inputStr.split(" ");
if(strs.length==3){//课程信息:课程名称、课程性质、考核方式
String courseName=strs[0];
String courseNature=strs[1];
String courseAccess=strs[2];
Course cour=new Course(courseName,courseNature,courseAccess);
if(cour.isCourse()&&cour.iscourseName()&&cour.isFindCourse(courList)) {
courList.add(cour);//增加一条课程记录
}
}
else if(strs.length==4){//考查课程成绩信息包括：学号、姓名、课程名称、期末成绩
String num=strs[0];
String name=strs[1];
String courseName=strs[2];//课程名称
int finalGrade=Integer.parseInt(strs[3]);
Class cla=new Class(num);
InspectGrade grade=new InspectGrade(finalGrade);
Student stu=new Student(num,name,grade);
Course cour=new Course(courseName);
CourseSelect courSe=new CourseSelect(cour,stu,grade);
if(stu.isName()&&stu.isNum()&&grade.isGrade()) {//学号，姓名和成绩信息不为异常情况
courSeList.add(courSe);//增加一条选课记录
if(!courSe.isCourseExist(courList)) {
courSeList.get(courSeList.size()-1).grade=null;
}
else {
if(courSe.course.courseAssess.equals("考试")) {
System.out.println(num+" "+name+" "+": access mode mismatch");
courSeList.get(courSeList.size()-1).grade=null;
}
}
if(cla.isFindClass(classList)) {
classList.add(cla);
}
}
//mapClass.put(cla, courSeList);
//mapCourse.put(courseName, courSeList);
}
else if(strs.length==5) {//考试课程成绩信息包括：学号、姓名、课程名称、平时成绩、期末成绩
String num=strs[0];
String name=strs[1];
String courseName=strs[2];
int usualGrade=Integer.parseInt(strs[3]);
int finalGrade=Integer.parseInt(strs[4]);
Class cla=new Class(num);
ExamGrade grade=new ExamGrade(usualGrade,finalGrade);
Student stu=new Student(num,name,grade);
Course cour=new Course(courseName);
CourseSelect courSe=new CourseSelect(cour,stu,grade);
if(stu.isName()&&stu.isNum()&&grade.isGrade()) {
if(courSe.isCourseExist(courList)) {
courSeList.add(courSe);//增加一条选课记录
}
if(cla.isFindClass(classList)) {
classList.add(cla);
}
}
//mapClass.put(cla, courSeList);
// mapCourse.put(courseName, courSeList);
}
else {//实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
String num=strs[0];
String name=strs[1];
String courseName=strs[2];
int times=Integer.parseInt(strs[3]);
int [] grades=new int[20];
for(int i=0;i<strs.length-4;i++) {
grades[i]=Integer.parseInt(strs[i+4]);
}
Class cla=new Class(num);
ExperimentGrade grade=new ExperimentGrade(times,grades);
Student stu=new Student(num,name,grade);
Course cour=new Course(courseName);
CourseSelect courSe=new CourseSelect(cour,stu,grade);
if(stu.isName()&&stu.isNum()&&grade.isGrade()&&grade.isTimes()) {
courSeList.add(courSe);//增加一条选课记录
if(cla.isFindClass(classList)) {
classList.add(cla);
}
if(!courSe.isCourseExist(courList)) {
courSeList.get(courSeList.size()-1).grade=null;
}
else {
//输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
if((times+4)!=strs.length) {
System.out.println(num+" "+name+" "+": access mode mismatch");
courSeList.get(courSeList.size()-1).grade=null;
}
}
}
// mapClass.put(cla, courSeList);
// mapCourse.put(courseName, courSeList);
}
}//while(1)
Collections.sort(courSeList, new Comparator<CourseSelect>() {
@Override
public int compare(CourseSelect s1, CourseSelect s2) {
return s1.getStudentNum().compareTo(s2.getStudentNum());
}
});
for(CourseSelect courSet:courSeList) {//输出学生所有课程总成绩的平均分
courSet.printStuGrade();
}
//按课程名称的字符顺序输出
Collections.sort(courList, new Comparator<Course>() {
@Override
public int compare(Course s1, Course s2) {
return s1.getCourseName().compareTo(s2.getCourseName());
}
});
for(Course cour:courList) {//输出课程成绩
cour.printCourseGrade(courSeList);
}
//3）班级所有课程总成绩平均分按班级由低到高排序输出
Collections.sort(classList, new Comparator<Class>() {
@Override
public int compare(Class s1, Class s2) {
return s1.getClassID().compareTo(s2.getClassID());
}
});
for(Class cla :classList) {//输出班级总成绩平均分，按班级由低到高排序输出
cla.classGrade(courSeList);
}
}//void main()
}第8次作业其他
分析：
7-1 容器-ArrayList-排序实现排序和7-3 jmu-Java-02基本语法-03-身份证排序：主要的部分都是实现排序，包括上面的成绩类也有要实现排序的要求。排序在java中还是比较重要，加上java中的排序其实也比较简单，很多时候只需要写一个简单的函数就可以排序。
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack：主要是实现一个接口，在Java中，接口（Interface）是一种定义抽象方法集合的类型。接口可以被类实现（implements），从而使类具备接口中定义的方法。接口是Java中实现多态的一种机制，它定义了一组规范，同时可以让不同的类去实现这些规范。在本题我们是定义IntegerStack接口，实现一些栈的要求。
7-5 jmu-Java-03面向对象基础-05-覆盖：主要就是java中object类自带的两个方法equals和toString方法，重写一下就行，比较简单，教材中关于这两个方法也写的比较清楚。简单说一下，equals就是一个比较，toString显示一些信息，它自带实现方法我们基本用不到，所以要重写来实现我们自己要用的功能。
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
分析：成绩3相比成绩2主要就是修改类结构，将成绩类的继承关系改为组合关系，然后将成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。所以要把成绩2中继承的关系要改成组合关系。所以在写成绩3首先要知道组合关系是如何实现的，这样才能好写代码。
错误：在本题还有上个题目好像也有，出现了浮点数精度的问题，就是判断权重是否为1时出现。一开始就是直接用==判断，但有错误，后来将double改为float好一点，但是治标不治本。最后还是改成这种判断区间才解决。下面两张图很明显的区别
public boolean isAddWeigths() {
float sumWeight=0;
for(double temp:weigths) {
sumWeight+=temp;
}
//System.out.println(sumWeight);
double epsilon = 0.000001; // 允许的误差范围
if (Math.abs(sumWeight - 1.0) <= epsilon) {
return true;
}
else {
System.out.println(courseName+" "+": weight value error");
return false;
}
}
类图：
代码：
import java.util.*;
//课程成绩统计程序-3
/*组合：最强的关系，又称为强聚合、这种关系就类似于人和大脑、手脚等的关系，
组合关系中，整件拥有部件的生命周期，所以整件删除时，部件一定会跟着删除。
组合侧重，在构造函数中实例化组合的对象，通过new方法，或者间接通过new
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，
课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
*/
//课程成绩类
class CourseGrade{
List<SubGrade> subList;
CourseGrade(){
subList=new ArrayList<>();
}
//添加一个成绩
public boolean addSubGrade(int score,double weight) {
if(score<0||score>100) {//成绩的取值范围是【0,100】
System.out.println("wrong format");
return false;
}
else {
SubGrade subrade=new SubGrade(score,weight);
subList.add(subrade);
return true;
}
}
//计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。
public int totalGrade() {
float sumGrade=0;
for(SubGrade suG:subList) {
sumGrade+=suG.getScore();
}
return (int)sumGrade;
}
}
//分项成绩
class SubGrade{
private int divideGrade;//成绩分值
private double weight; //权重
public SubGrade(int divideGrade,double weight) {
this.divideGrade=divideGrade;
this.weight=weight;
}
public int getDivideGrade() {
return divideGrade;
}
public double getWeight() {
return weight;
}
public double getScore() {
return divideGrade*weight;
}
}
class Course{ //课程
String courseName;
String courseNature;//课程性质,必修课、选修课、实验课
String courseAssess;//考核方式,考试、考察、实验
int sugNum;//分项成绩数量
double[] weigths=new double[20];//权重
public Course(String courseName,String courseNature,String courseAssess) {
this.courseName=courseName;
this.courseNature=courseNature;
this.courseAssess=courseAssess;
}
public Course(String courseName) {
this.courseName=courseName;
}
public String getCourseName() {
return courseName;
}
public String getCourseNature() {//得到课程性质,必修课、选修课、实验课
return courseNature;
}
public String getCourseAssess() {//得到考核方式
return courseAssess;
}
public void setSugNum(int sugNum) {
this.sugNum=sugNum;
}
public void setWeigths() {
}
//3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，
//输出：课程名称+" : course type & access mode mismatch"
public boolean isCourse() {
if(courseNature.equals("必修")&&courseAssess.equals("考试")) {
return true;
}
else if(courseNature.equals("选修")&&(courseAssess.equals("考试")||courseAssess.equals("考察"))) {
return true;
}
else if(courseNature.equals("实验")&&courseAssess.equals("实验")) {
return true;
}
else {
System.out.println(courseName+" : course type & access mode mismatch");
return false;
}
}
//课程名称不超过10个字符
public boolean iscourseName() {
if(courseName.matches(".{1,10}")) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
public Course isFindCourse(List<Course> courseList) {//是否有相同课程
for(Course cou:courseList) {
if(courseName.equals(cou.getCourseName())) {
return cou;
}
}
return null;
}
//判断分项成绩权重值的总和是否等于1
//如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
public boolean isAddWeigths() {
float sumWeight=0;
for(double temp:weigths) {
sumWeight+=temp;
}
//System.out.println(sumWeight);
double epsilon = 0.000001; // 允许的误差范围
if (Math.abs(sumWeight - 1.0) <= epsilon) {
return true;
}
else {
System.out.println(courseName+" "+": weight value error");
return false;
}
}
//单门课程成绩按课程名称的字符顺序输出
void printCourseGrade(List<CourseSelect> courSeList) {
int sum=0;
int number=0;
for(CourseSelect cous:courSeList) {
if(cous.courseGrade!=null) {
if(courseName.equals(cous.course.courseName)){
sum+=cous.getTotalGrade();
number++;
}
}
}
if(number!=0) {
System.out.println(courseName+" "+sum/number);
}
else {
System.out.println(courseName+" has no grades yet");
}
}
}
class Student{ //学生
String num;
String name;
public Student(String num,String name) {
this.num=num;
this.name=name;
}
public String getNum() {
return num;
}
public String getName() {
return name;
}
//判断学号由8位数字组成
boolean isNum() {
if(num.matches("[0-9]{8}")) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
//判断姓名不超过10个字符
boolean isName() {
if(name.matches(".{1,10}")) {
return true;
}
else {
System.out.println("wrong format");
return false;
}
}
String getClassID() {
return num.substring(0,6);
}
}
class Class{ //班级
String classID;
List<Student> students;
Class(String num){
this.classID=num.substring(0,6);
}
String getClassID() {
return classID;
}
boolean isFindClass(List<Class> classList) {
//int flag=1;
for(Class cla:classList) {
if(classID.equals(cla.classID)) {
//flag=0;
return false;
}
}
return true;
}
void classGrade(List<CourseSelect> courSeList) {
int sum=0;
int number=0;
int flag=1;
for(CourseSelect cous:courSeList) {
if(cous.courseGrade!=null) {
if(classID.equals(cous.student.getClassID())) {
sum+=cous.getTotalGrade();
number++;
}
}
else {
flag=0;
}
}
if(number==0) {
System.out.println(classID+" "+"has no grades yet");
}
else {
System.out.println(classID+" "+sum/number);
}
//return sum/number;
}
}
//考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
//实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
class CourseSelect{//选课
Course course;
Student student;
//Grade grade;
CourseGrade courseGrade;
public CourseSelect(Course course,Student student,CourseGrade courseGrade) {
this.course = course;
this.student=student;
this.courseGrade=courseGrade;
}
public String getStudentNum() {
return student.getNum();
}
//如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
public boolean isCourseGrade() {
if(courseGrade!=null) {
return true;
}
else {
System.out.println(course.courseName+" has no grades yet");
return false;
}
}
//1）学生课程总成绩平均分按学号由低到高排序输出
//格式：学号+英文空格+姓名+英文空格+总成绩平均分
//如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
int getTotalGrade() {
return courseGrade.totalGrade();
}
void printStuGrade() {
if(courseGrade!=null) {
System.out.println(student.num+" "+student.name+" "+getTotalGrade());
}
else {
System.out.println(student.num+" "+student.name+" did not take any exams");
}
}
//2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
//考试/考察课程成绩格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
//1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，
//输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
boolean isCourseExist(List<Course> courseList) {
int flag=0;
for(Course cour:courseList) {
if(course.courseName.equals(cour.courseName)) {
course=cour;
flag=1;
}
}
if(flag==1) {
return true;
}
else {
System.out.println(course.courseName+" does not exist");
//System.out.println(student.num+" "+student.name+" :"+course.courseName+" does not exist");
return false;
}
}
}
public class Main {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
List<CourseSelect> courSeList=new ArrayList <>();//选课记录
List<Student> studentList=new ArrayList <>();//学生记录
List<Course> courList=new ArrayList <>();//课程记录
List<Class> classList=new ArrayList<>();//班级记录
while(true) {
String inputStr=input.nextLine();
if(inputStr.equals("end")) {
break;
}
String []strs=inputStr.split(" ");
if(strs.length==3&&strs[2].equals("考察")){//考察课信息格式：课程名称+课程性质+考核方式
String courseName=strs[0];
String courseNature=strs[1];
String courseAccess=strs[2];
Course cour=new Course(courseName,courseNature,courseAccess);
if(cour.isCourse()&&cour.iscourseName()&&(cour.isFindCourse(courList)==null)) {
courList.add(cour);//增加一条课程记录
}
}
else if(strs[2].equals("考试")) {//考试课信息格式：课程名称+课程性质+考核方式+平时成绩的权重+期末成绩的权重
String courseName=strs[0];
String courseNature=strs[1];
String courseAccess=strs[2];
Course cour=new Course(courseName,courseNature,courseAccess);
if(cour.isCourse()&&(cour.isFindCourse(courList)==null)) {
double usualWeight=Double.parseDouble(strs[3]);//平时成绩的权重
double finalWeight=Double.parseDouble(strs[4]);//期末成绩的权重
cour.weigths[0]=usualWeight;
cour.weigths[1]=finalWeight;
if(cour.iscourseName()&&cour.isAddWeigths()) {
courList.add(cour);//增加一条课程记录
}
}
/*if(cour.isCourse()&&cour.iscourseName()&&cour.isAddWeigths()&&(cour.isFindCourse(courList)==null)) {
courList.add(cour);//增加一条课程记录
}*/
}
//实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+
//分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
else if(strs[2].equals("实验")) {
String courseName=strs[0];
String courseNature=strs[1];
String courseAccess=strs[2];
if(strs.length<4) {
System.out.println(courseName+" : course type & access mode mismatch");
}
else {
int numN=Integer.parseInt(strs[3]);//分项成绩数量n
//实验次数至少4次，不超过9次
if(numN<4||numN>9) {
System.out.println("wrong format");
}
else {
double [] weigthValues=new double[20];
if((numN+4)!=strs.length) {
System.out.println(courseName+" "+": number of scores does not match");
//courSeList.get(courSeList.size()-1).courseGrade=null;
}
else {
for(int i=0;i<numN;i++) {
weigthValues[i]=Double.parseDouble(strs[i+4]);
}
Course cour=new Course(courseName,courseNature,courseAccess);
cour.setSugNum(numN);
for(int i=0;i<numN;i++) {
cour.weigths[i]=weigthValues[i];
//System.out.println(cour.weigths[i]);
}
if(cour.isCourse()&&cour.iscourseName()&&cour.isAddWeigths()&&(cour.isFindCourse(courList)==null)) {
courList.add(cour);//增加一条课程记录
}
}
}
}
}
else if(strs.length==4){//考查课程成绩信息包括：学号、姓名、课程名称、期末成绩
String num=strs[0];
String name=strs[1];
String courseName=strs[2];//课程名称
int finalGrade=Integer.parseInt(strs[3]);
Class cla=new Class(num);
Student stu=new Student(num,name);
Course cour=new Course(courseName);
CourseGrade courGrade=new CourseGrade();
courGrade.addSubGrade(finalGrade, 1.0);//考察
CourseSelect courSe=new CourseSelect(cour,stu,courGrade);
if(stu.isName()&&stu.isNum()) {//学号，姓名和成绩信息不为异常情况
courSeList.add(courSe);//增加一条选课记录
if(!courSe.isCourseExist(courList)) {
courSeList.get(courSeList.size()-1).courseGrade=null;
}
else {
if(!courSe.course.courseAssess.equals("考察")) {
System.out.println(num+" "+name+" "+": access mode mismatch");
courSeList.get(courSeList.size()-1).courseGrade=null;
}
}
if(cla.isFindClass(classList)) {
classList.add(cla);
}
}
}
else if(strs.length==5) {//考试课程成绩信息包括：学号、姓名、课程名称、平时成绩、期末成绩
String num=strs[0];
String name=strs[1];
String courseName=strs[2];
int usualGrade=Integer.parseInt(strs[3]);
int finalGrade=Integer.parseInt(strs[4]);
Class cla=new Class(num);
Student stu=new Student(num,name);
Course cour=new Course(courseName);
Course tempCour=cour.isFindCourse(courList);
CourseGrade courGrade=new CourseGrade();
courGrade.addSubGrade(usualGrade,tempCour.weigths[0]);//考试
courGrade.addSubGrade(finalGrade,tempCour.weigths[1]);//考试
CourseSelect courSe=new CourseSelect(cour,stu,courGrade);
if(stu.isName()&&stu.isNum()) {
if(courSe.isCourseExist(courList)) {
courSeList.add(courSe);//增加一条选课记录
}
if(cla.isFindClass(classList)) {
classList.add(cla);
}
}
}
//实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），
//实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
else {//实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
String num=strs[0];
String name=strs[1];
String courseName=strs[2];
int [] grades=new int[20];
int times=0;
for(int i=0;i<strs.length-3;i++) {
grades[i]=Integer.parseInt(strs[i+3]);
times++;
}
Class cla=new Class(num);
Student stu=new Student(num,name);
Course cour=new Course(courseName);
Course tempCour=cour.isFindCourse(courList);
CourseGrade courGrade=new CourseGrade();
if(tempCour!=null) {
for(int i=0;i<grades.length;i++) {
courGrade.addSubGrade(grades[i],tempCour.weigths[i]);
}
}
CourseSelect courSe=new CourseSelect(cour,stu,courGrade);
if(stu.isName()&&stu.isNum()) {
courSeList.add(courSe);//增加一条选课记录
if(cla.isFindClass(classList)) {
classList.add(cla);
}
if(!courSe.isCourseExist(courList)) {
courSeList.get(courSeList.size()-1).courseGrade=null;
}
else {
//输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
if(tempCour.sugNum!=times) {
System.out.println(num+" "+name+" "+": access mode mismatch");
courSeList.get(courSeList.size()-1).courseGrade=null;
}
}
}
}
}//while(1)
Collections.sort(courSeList, new Comparator<CourseSelect>() {
@Override
public int compare(CourseSelect s1, CourseSelect s2) {
return s1.getStudentNum().compareTo(s2.getStudentNum());
}
});
for(CourseSelect courSet:courSeList) {//输出学生所有课程总成绩的平均分
courSet.printStuGrade();
}
//按课程名称的字符顺序输出
Collections.sort(courList, new Comparator<Course>() {
@Override
public int compare(Course s1, Course s2) {
return s1.getCourseName().compareTo(s2.getCourseName());
}
});
for(Course cour:courList) {//输出课程成绩
cour.printCourseGrade(courSeList);
}
//3）班级所有课程总成绩平均分按班级由低到高排序输出
Collections.sort(classList, new Comparator<Class>() {
@Override
public int compare(Class s1, Class s2) {
return s1.getClassID().compareTo(s2.getClassID());
}
});
for(Class cla :classList) {//输出班级总成绩平均分，按班级由低到高排序输出
cla.classGrade(courSeList);
}
}//void main()
}
期末考试：
分析：期末考试的编程题目主要还是考察继承和多态方面的问题，题目也比较简单，7-1 立体图形问题，主要就是写一个抽象类，然后Cube和RegularPyramid继承抽象类，还一个定义在main中的静态函数。2和3题也差不多，7-3 魔方排序问题中要实现Comparable接口来实现排序，主要就是一个compareTo() 方法，该方法接受一个类型为 T 的参数，并返回一个整数值。根据 compareTo() 方法的返回值，可以判断两个对象的大小关系，然后用来排序。然后7-4 销售步枪问题（附加题），没什么好说的，干就完了。
三、改进建议
代码还是有很多不合理的地方，特别是成绩2中的处理，就是输出学生成绩，我是没有写存学生信息的数组，但是在3中我是改过来了。还有输入的处理，这方面处理的不是很好。但是我目前也没想到比较好的方法。
四、总结和改进
经过差不多一个学期的java学习，已经学会了用java输出hello world。好了，完了。开个玩笑，java是一门面向对象的语言，所以在java中一切都是基于类的，
一开始，还是不是很清楚和很好运用类的思想或者面向对象的思想去解决问题。但当慢慢学习后，就能慢慢掌握。在本阶段（10-16周）中主要还是学到java中的几种模式还有继承和多态。特别是继承和多态，算是java中非常重要的思想。还有java设计时几种原则：单一职责原则（SRP）：一个类只应该有一个引起它变化的原因。开放封闭原则（OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。里氏替换原则（LSP）：子类型必须能够替换掉它们的父类型。依赖倒置原则（DIP）：高层模块不应该依赖于低层模块，两者都应该依赖于抽象接口；抽象接口不应该依赖于具体实现，具体实现应该依赖于抽象接口。接口隔离原则（ISP）：不应该强迫一个类实现它不需要的接口，应该将接口拆分成更小和更具体的部分，以便客户端只需要知道它们感兴趣的部分。迪米特法则（LOD）：一个对象应该对其他对象有尽可能少的了解，通常称为“最少知识原则”。这些都是在设计类时比较重要。
posted on
浙公网安备 33010602011771号