Yqw第三次博客作业
目录前言
⭕ 好久不见，这是这个学期最后一次Blog啦，为期一学期的java学习终于要告一段落了。老实说，对于《面向对象程序设计》（Java）还是不太懂，但是Java的实训在明年，今年是C语言，暑假还再可以挣扎一下。
总结所涉及到的知识点、题量、难度等情况
6-8次的pta没有延续之前的菜单计价程序，主要是围绕课程成绩统计程序进行的。第六次大作业就是成绩统计程序，第七次大作业则增加了对HashMap和多态的一个考察，第八次大作业则是增加了对Array.*部分知识点的考察。题量还可以，难度的话，没有延续菜单的难度，已经很知足了，两次迭代也没有在类设计方面发生什么变化，所以从某些方面而言也算是简单了不少（就是可能在细节方面多了一些测试点）。
☀️ 多态是指同一个方法在不同的对象上具有不同的行为。在Java编程中，多态可以通过重载和重写实现。
设计与分析
成绩统计程序-1
得分情况：
代码：
import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Main main = new Main();
Scanner scanner = new Scanner(System.in);
ArrayList<String> messages = new ArrayList<String>();
ArrayList<Course> coures = new ArrayList<Main.Course>();
ArrayList<Score> scores = new ArrayList<Main.Score>();
ArrayList<Student> students = new ArrayList<Main.Student>();
ArrayList<Grades> gradess = new ArrayList<Main.Grades>();
while (true) {
String string = scanner.nextLine();
if ("end".equals(string)) {
break;
}else {
String[] arr = string.split(" ");
if (arr.length==2) {
Course course = main.new Course();
course.name = arr[0];
if (arr[0].length()>10) {
messages.add("wrong format");
continue;
}
if (arr[1].length()!=2||arr[2].length()!=2) {
messages.add("wrong format");
continue;
}
if ("必修".equals(arr[1])) {
course.isCompulsory = true;
}else {
course.isCompulsory = false;
}
if (course.isCompulsory) {
course.examine = true;
}else {
messages.add("wrong format");
continue;
}
boolean flag=true;
for (int j = 0; j < coures.size(); j++) {
if (coures.get(j).name.equals(arr[0])) {
flag=false;
}
}
if (flag) {
coures.add(course);
}
}else if (arr.length==3) {
Course course = main.new Course();
course.name = arr[0];
if (arr[0].length()>10) {
messages.add("wrong format");
continue;
}
if (arr[1].length()!=2||arr[2].length()!=2) {
messages.add("wrong format");
continue;
}
if ("必修".equals(arr[1])) {
course.isCompulsory = true;
}else {
course.isCompulsory = false;
}
if (course.isCompulsory) {
if ("考察".equals(arr[2])) {
messages.add(arr[0]+" : course type & access mode mismatch");
continue;
}
course.examine = true;
}else {
if ("考察".equals(arr[2])) {
course.examine = false;
}else {
course.examine = true;
}
}
boolean flag=true;
for (int j = 0; j < coures.size(); j++) {
if (coures.get(j).name.equals(arr[0])) {
flag=false;
}
}
if (flag) {
coures.add(course);
}
}else if (arr.length==4) {
int k=0;
if (arr[0].length()!=8) {
messages.add("wrong format");
continue;
}
if (arr[1].length()>10) {
messages.add("wrong format");
continue;
}
try {
int nums = Integer.parseInt(arr[0]);
k = Integer.parseInt(arr[3]);
} catch (Exception e) {
messages.add("wrong format");
continue;
}
if (k>100||k<0) {
messages.add("wrong format");
continue;
}
Student student = null;
for (int j = 0; j < students.size(); j++) {
if (students.get(j).snum.equals(arr[0])) {
student = students.get(j);
}
}
if (student==null) {
student = main.new Student();
student.sname = arr[1];
student.snum = arr[0];
students.add(student);
}
String gnum = arr[0].substring(0,6);
Grades grades =null;
for (int j = 0; j < gradess.size(); j++) {
if (gradess.get(j).gnum.equals(gnum)) {
grades =gradess.get(j);
}
}
if (grades==null) {
grades = main.new Grades();
grades.gnum = gnum;
grades.students.add(student);
gradess.add(grades);
}else {
grades.students.add(student);
}
Course course =null;
for (int j = 0; j < coures.size(); j++) {
if (coures.get(j).name.equals(arr[2])) {
course =coures.get(j);
}
}
if (course==null) {
messages.add(arr[2]+" does not exist");
continue;
}
if (course.examine) {
messages.add(arr[0]+" "+arr[1]+" : access mode mismatch");
continue;
}
Score score = main.new Score();
score.course = course;
score.student = student;
score.examination = k;
scores.add(score);
}else if (arr.length==5){
int p = 0;
int k=0;
if (arr[0].length()!=8) {
messages.add("wrong format");
continue;
}
if (arr[1].length()>10) {
messages.add("wrong format");
continue;
}
try {
int nums = Integer.parseInt(arr[0]);
k = Integer.parseInt(arr[4]);
p = Integer.parseInt(arr[3]);
} catch (Exception e) {
messages.add("wrong format");
continue;
}
if (k>100||k<0) {
messages.add("wrong format");
continue;
}
Student student = null;
for (int j = 0; j < students.size(); j++) {
if (students.get(j).snum.equals(arr[0])) {
student = students.get(j);
}
}
if (student==null) {
student = main.new Student();
student.sname = arr[1];
student.snum = arr[0];
students.add(student);
}
String gnum = arr[0].substring(0,6);
Grades grades =null;
for (int j = 0; j < gradess.size(); j++) {
if (gradess.get(j).gnum.equals(gnum)) {
grades =gradess.get(j);
}
}
if (grades==null) {
grades = main.new Grades();
grades.gnum = gnum;
grades.students.add(student);
gradess.add(grades);
}else {
grades.students.add(student);
}
Course course =null;
for (int j = 0; j < coures.size(); j++) {
if (coures.get(j).name.equals(arr[2])) {
course =coures.get(j);
}
}
if (course==null) {
messages.add(arr[2]+" does not exist");
continue;
}
if (!course.examine) {
messages.add(arr[0]+" "+arr[1]+" : access mode mismatch");
continue;
}
Score score = main.new Score();
score.course = course;
score.student = student;
score.examination = k;
score.ordinary = p;
scores.add(score);
}
}
}
for (int j = 0; j < students.size(); j++) {
for (int i = j; i < students.size(); i++) {
if (Integer.parseInt(students.get(j).snum)>Integer.parseInt(students.get(i).snum)) {
Student student = main.new Student();
student = students.get(i);
students.set(i, students.get(j));
students.set(j, student);
}
}
}
Comparator comparator = Collator.getInstance(java.util.Locale.CHINESE);
String[] courS = new String[coures.size()];
for (int i = 0; i < courS.length; i++) {
courS[i] = coures.get(i).name;
}
Arrays.sort(courS, comparator);
ArrayList<Course> courses = new ArrayList<Main.Course>();
for (int i = 0; i < courS.length; i++) {
for (int j = 0; j < coures.size(); j++) {
if (courS[i].equals(coures.get(j).name)) {
courses.add(coures.get(j));
}
}
}
for (int j = 0; j < gradess.size(); j++) {
for (int i = j; i < gradess.size(); i++) {
if (Integer.parseInt(gradess.get(j).gnum)>Integer.parseInt(gradess.get(i).gnum)) {
Grades grades = main.new Grades();
grades = gradess.get(i);
gradess.set(i, gradess.get(j));
gradess.set(j, grades);
}
}
}
for (int j = 0; j < messages.size(); j++) {
System.out.println(messages.get(j));
}
for (int j = 0; j < students.size(); j++) {
Student student = students.get(j);
double sum=0;
int num=0;
if (scores.size()==0) {
System.out.println(student.snum+" "+student.sname+" "+"did not take any exams");
}else {
for (int i = 0; i < scores.size(); i++) {
if (student.snum.equals(scores.get(i).student.snum)) {
Course course = scores.get(i).course;
if (course.examine) {
sum+=Math.floor(scores.get(i).ordinary*0.3+scores.get(i).examination*0.7);
}else {
sum+=scores.get(i).examination;
}
num++;
}
}
System.out.println(student.snum+" "+student.sname+" "+String.valueOf(Math.floor(sum/num)).substring(0,2));
student.sumAverage = Math.floor(sum/num);
}
}
for (int j = 0;j < courses.size(); j++) {
Course course = courses.get(j);
double sum=0;
double sump=0;
double sumk=0;
int num=0;
if (scores.size()==0) {
System.out.println(course.name+" "+"has no grades yet");
}else {
for (int i = 0; i < scores.size(); i++) {
Course course1 = scores.get(i).course;
if (course.name.equals(course1.name)) {
if (course.examine) {
sum+=Math.floor(scores.get(i).ordinary*0.3+scores.get(i).examination*0.7);
sump += scores.get(i).ordinary;
sumk+=scores.get(i).examination;
}else {
sum+=scores.get(i).examination;
sumk+=scores.get(i).examination;
}
num++;
}
}
if (course.examine) {
System.out.println(course.name+" "+String.valueOf(Math.floor(sump/num)).substring(0,2)+" "+
String.valueOf(Math.floor(sumk/num)).substring(0,2)+" "+String.valueOf(Math.floor(sum/num)).substring(0,2));
}else {
System.out.println(course.name+" "+
String.valueOf(Math.floor(sumk/num)).substring(0,2)+" "+String.valueOf(Math.floor(sum/num)).substring(0,2));
}
}
}
for (int j = 0; j < gradess.size(); j++) {
double sum=0;
int num=0;
ArrayList<Student> students1 = gradess.get(j).students;
if (scores.size()==0) {
System.out.println(gradess.get(j).gnum+" "+"has no grades yet");
}else {
for (int i = 0; i < students1.size(); i++) {
sum+=students1.get(i).sumAverage;
num++;
}
System.out.println(gradess.get(j).gnum+" "+String.valueOf(Math.floor(sum/num)).substring(0,2));
}
}
}
class Student {
String snum;
String sname;
double sumAverage=0;
}
class Course{
boolean isCompulsory;
String name;
boolean examine;
}
class Score{
Student student;
Course course;
double ordinary=0;
double examination=0;
}
class Grades{
String gnum;
ArrayList<Student> students=new ArrayList<Main.Student>();
}
}
类图：
圈复杂度：
分析：
我还是和之前差不多，把主要的放在了main函数中，在main中写了大量的if来判断输入，剩下的四个类（Student、Course、Score、Grades)主要是起到了声明变量的作用。
在主函数中创造了五个不同类型的ArrayList数组，用于存储不同类型的输入数据类别，创造一个未遇到end就一直输入的死循环，再用很多if对输入进行判断以及一些后续操作。
成绩统计程序-2
得分情况：
代码：
import java.util.*;
import java.text.Collator;
public class Main {
public static void main(String[] args) {
ArrayList<课程>lesson=new ArrayList();//课程信息
ArrayList <班级>classes=new ArrayList();//班级信息
ArrayList <选课>choice=new ArrayList();//课程学生成绩;
ArrayList <String>成绩记录=new ArrayList();
String regex1=".{0,10}[ ](必修|选修|实验)[ ](考试|考察|实验)";//课程信息
String regex2=".{0,10}[ ](必修)[ ](考试)";//必修课程信息
String regex3=".{0,10}[ ](选修)[ ](考试|考察)";//选修课程信息
String regex0=".{0,10}[ ](实验)[ ](实验)";//选修课程信息
String regex4="\\d{8}[ ].{0,10}[ ].{0,10}[ ](\\d|[1-9]\\d|100)[ ](\\d|[1-9]\\d|100)";//考试成绩输入
String regex5="\\d{8}[ ].{0,10}[ ].{0,10}[ ](\\d|[1-9]\\d|100)";//考察成绩输入
Scanner input=new Scanner(System.in);
String l;
while(true) {
l=input.nextLine();
String brr[]=l.split(" ");
int len=brr.length;//
if(l.equals("end")) {
break;
}
else if(l.matches(regex1) ){//如果输入是课程信息的格式，java 必修 考试
String arr[]=l.split(" ");
int flag=0;
if(l.matches(regex3)||l.matches(regex2)||l.matches(regex0)) {
//0是没有添加过，1是添加过
课程 k=new 课程(arr[0], arr[1], arr[2]);
for(课程 c:lesson) {
if(c.课程名称.equals(k.课程名称)) {
flag=1;
}
}
if(flag==0) {//没添加过
lesson.add(k);
}
}
else {//java : course type & access mode mismatch
System.out.println(arr[0]+" : course type & access mode mismatch");
}
//不知道有没有else
}
else if(len==5&&brr[0].matches("^[0-9]{8}$")&&brr[1].length()<=10&&brr[2].length()<=10&&brr[3].matches("^[0-9]{1,2}|(100)$")&&brr[4].matches("^[0-9]{1,2}|(100)$")) {//如果输入的是考试成绩，20201103 张三 java 20 40
int x=0;
int yc=0;
String arr[]=l.split(" ");
if(arr[3]!=null) {
if(Integer.parseInt(arr[3])<0||Integer.parseInt(arr[3])>100) {
System.out.println("wrong format");
continue;
}
}
String 班号=arr[0].substring(0,6);
for(String s:成绩记录) {
if(s.equals(arr[0]+arr[1]+arr[2])) {
x=1;
}
}
if(x==1) {
continue;
}
成绩记录.add(arr[0]+arr[1]+arr[2]);
学生 stu=new 学生(arr[1], arr[0]);
int flag=0;//如果班号存过
for(int i=0;i<classes.size();i++) {
if(班号.equals(classes.get(i).班号)) {
flag=1;//班号存过
int temp=1;//1是没存过，0是存过
for(学生 b:classes.get(i).students) {
if(b.学号.equals(stu.学号)) {
temp=0;
break;
}
}
if(temp==1) {
classes.get(i).添加学生(stu);
}
break;
}
}
if(flag==0) {//班号没存过
班级 bj=new 班级(班号);
bj.添加学生(stu);
classes.add(bj);
}//把学生添加到班级里
String typle=Typleoflesson(lesson, arr[2]);
if(typle==null) {//学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
System.out.println(arr[2]+" does not exist");
yc=1;
}
else if(typle.equals("考试")) {
//先不添加班级
if(arr[3]!=null&&arr[4]!=null){
考试成绩 k=new 考试成绩(Integer.parseInt(arr[3]), Integer.parseInt(arr[4]));
选课 choose=new 选课(stu, arr[2], k);
for(int i=0;i<classes.size();i++) {
if(classes.size()!=0)
if(班号.equals(classes.get(i).班号)) {
classes.get(i).选课信息添加(choose);
}
}
choice.add(choose);
}
}
else if(typle.equals("考察")) {//学号+英文空格+姓名+英文空格+": access mode mismatch"
if(yc==0) {
System.out.println(arr[0]+" "+arr[1]+" "+": access mode mismatch");//
}
}
}
else if(len==4&&brr[0].matches("^[0-9]{8}$")&&brr[1].length()<=10&&brr[2].length()<=10&&brr[3].matches("^[0-9]{1,2}|(100)$")) {//如果输入的是考察成绩，20201103 张三 java 20
int yc=0;
int x=0;
String arr[]=l.split(" ");
if(arr[3]!=null) {
if(Integer.parseInt(arr[3])<0||Integer.parseInt(arr[3])>100) {
System.out.println("wrong format");
continue;
}
}
String typle=Typleoflesson(lesson, arr[2]);//对照课表找arr
学生 stu=new 学生(arr[1], arr[0]);
for(String s:成绩记录) {
if(s.equals(arr[0]+arr[1]+arr[2])) {
x=1;
}
}
if(x==1) {
continue;
}
成绩记录.add(arr[0]+arr[1]+arr[2]);
int flag=0;
String 班号=arr[0].substring(0,6);
for(int i=0;i<classes.size();i++) {
if(班号.equals(classes.get(i).班号)) {
int temp=1;//1是没存过，0是存过
for(学生 b:classes.get(i).students) {
if(b.学号.equals(stu.学号)) {
temp=0;
break;
}
}
if(temp==1) {
classes.get(i).添加学生(stu);
}
flag=1;
}
}
if(flag==0) {
班级 bj=new 班级(班号);
bj.添加学生(stu);
classes.add(bj);//把学生添加到班级里
}
if(typle==null) {//课表里没有找到该门课
//System.out.println(arr[0]+" "+arr[1]+" "+arr[2]+" "+"dose not exist");
//System.out.println("java does not exist");
System.out.println(arr[2]+" does not exist");
yc=1;
}
else if(typle.equals("考试")) {//先不添加班级
if(yc==0) {
System.out.println(arr[0]+" "+arr[1]+" "+": access mode mismatch");
}
}
else if(typle.equals("考察")) {//学号+英文空格+姓名+英文空格+": access mode mismatch"
考察成绩 k=new 考察成绩(Integer.parseInt(arr[3]));
选课 choose=new 选课(stu, arr[2], k);
for(int i=0;i<classes.size();i++) {
if(班号.equals(classes.get(i).班号)) {
classes.get(i).选课信息添加(choose);
}
}
choice.add(choose);
}
}
else if(brr[0].matches("^[0-9]{8}$")&&brr[1].length()<=10&&brr[2].length()<=10&&isNum(brr[3])&&Integer.parseInt(brr[3])>=4&&Integer.parseInt(brr[3])<=9) {
int x=0;
int yc=0;
int flagg=0;
String arr[]=l.split(" ");
for(int i=0;i<arr.length;i++) {
if(i>=4) {
if(Integer.parseInt(arr[i])>100||Integer.parseInt(arr[i])<0) {
System.out.println("wrong format");
flagg=1;
break;
}
}
}
if(flagg==1) {
continue;
}
String 班号=arr[0].substring(0,6);
for(String s:成绩记录) {//添加过该条成绩
if(s.equals(arr[0]+arr[1]+arr[2])) {
x=1;
}
}
if(x==1) {
continue;
}
成绩记录.add(arr[0]+arr[1]+arr[2]);
学生 stu=new 学生(arr[1], arr[0]);
int flag=0;//如果班号存过
for(int i=0;i<classes.size();i++) {
if(班号.equals(classes.get(i).班号)) {
flag=1;//班号存过
int temp=1;//1是没存过，0是存过
for(学生 b:classes.get(i).students) {
if(b.学号.equals(stu.学号)) {
temp=0;
break;
}
}
if(temp==1) {
classes.get(i).添加学生(stu);
}
break;
}
}
if(flag==0) {//班号没存过
班级 bj=new 班级(班号);
bj.添加学生(stu);
classes.add(bj);
}//把学生添加到班级里
String typle=Typleoflesson(lesson, arr[2]);///
if(typle==null) {//学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
//System.out.println(arr[0]+" "+arr[1]+" "+arr[2]+" "+"dose not exist");
System.out.println(arr[2]+" does not exist");
yc=1;
}
if(typle==null) {//课表里没有找到该门课
//System.out.println(arr[0]+" "+arr[1]+" "+arr[2]+" "+"dose not exist");///////////////////////////
//System.out.println("java does not exist");
System.out.println(arr[2]+" does not exist");
yc=1;
}
if(typle.equals("实验")) {
int num=Integer.parseInt(brr[3]);
if((arr.length-4)!=num) {
System.out.println(arr[0]+" "+arr[1]+" "+": access mode mismatch");//
}
else {
ArrayList<Integer>xy=new ArrayList<Integer>();
for(int i=0;i<arr.length;i++) {
if(i>=4) {
xy.add(Integer.parseInt(arr[i]));
}
}
实验成绩 k=new 实验成绩(xy);
选课 choose=new 选课(stu, arr[2], k);
for(int i=0;i<classes.size();i++) {
if(班号.equals(classes.get(i).班号)) {
classes.get(i).选课信息添加(choose);
}
}
choice.add(choose);
}
}
}
else {
System.out.println("wrong format");
}
}//for循环
Collections.sort(lesson);
Collections.sort(classes);
输出 system=new 输出(lesson, classes, choice);
system.systemoutStudent();
system.systemoutLesson();
system.systemoutClasses();
}
public static String Typleoflesson(ArrayList<课程>lesson,String name ) {
for(int i=0;i<lesson.size();i++) {
if(lesson.get(i)!=null) {
if(name.equals(lesson.get(i).课程名称)) {
return lesson.get(i).考核方式;
}
}
}
return null;
}
private static boolean isNum(String str) {
if (str.length() == 0 || str == null)
return false;
for (int i = 0; i < str.length(); i++){
if (!Character.isDigit(str.charAt(i))){
return false;
}
}
return true;
}
}
class 课程 implements Comparable<课程>{
String 课程名称;
String 课程性质;
String 考核方式;
public 课程(String 课程名称, String 课程性质, String 考核方式) {
super();
this.课程名称 = 课程名称;
this.课程性质 = 课程性质;
this.考核方式 = 考核方式;
}
@Override
public int compareTo(课程 o) {//按照课程名字排序
String[] arrays=new String[2];
arrays[0]=this.课程名称;
arrays[1]=o.课程名称;
Comparator com = Collator.getInstance(java.util.Locale.CHINA);
Arrays.sort(arrays, com);
if(arrays[0].equals(o.课程名称)) {
return 1;
}
if(arrays[0].equals(this.课程名称)) {
return -1;
}
else
return 0;
}
}
class 学生 implements Comparable<学生>{//组合
String 姓名;
String 学号;
public 学生(String 姓名, String 学号) {
super();
this.姓名 = 姓名;
this.学号 = 学号;
}
@Override
public int compareTo(学生 o) {
// TODO Auto-generated method stub
String thisx=this.学号.substring(this.学号.length()-2);
String ox=o.学号.substring(o.学号.length()-2);
//xuehao
int thisxh=Integer.parseInt(thisx);
int oxh=Integer.parseInt(ox);
if(thisxh>oxh) {
return 1;
}
if(thisxh<oxh) {
return -1;
}
return 0;
}
}
class 班级 implements Comparable<班级>{
String 班号;
ArrayList<学生> students;
int 参与考试的人数=0;
double sum=0;
public ArrayList<选课> xuanke;
public 班级(String 班号) {
students=new ArrayList();
xuanke=new ArrayList();
this.班号 = 班号;
}
public void 添加学生(学生 stu) {
students.add(stu);
}
public void 选课信息添加(选课 choice) {
xuanke.add(choice);
}
public void 计算总成绩平均分(double 成绩) {
sum=sum+成绩;
参与考试的人数=参与考试的人数+1;
}
@Override
public int compareTo(班级 o) {
int thisxh=Integer.parseInt(this.班号);//this学号
int oxh=Integer.parseInt(o.班号);//o学号
if(thisxh>oxh) {
return 1;
}
if(thisxh<oxh) {
return -1;
}
return 0;
}
}
class 成绩{
public double 总成绩;
public double 平时成绩=0;
public double 期末成绩;
public 成绩() {
super();
}
}
class 考试成绩 extends 成绩{
int 平时成绩;
int 期末成绩;
public 考试成绩(int 平时成绩, int 期末成绩) {
super();
this.平时成绩 = 平时成绩;
this.期末成绩 = 期末成绩;
super.平时成绩=平时成绩;
super.期末成绩=期末成绩;
总成绩=(平时成绩*0.3+期末成绩*0.7);
}
}
class 考察成绩 extends 成绩{
int 期末成绩;
public 考察成绩(int 期末成绩) {
super();
this.期末成绩 = 期末成绩;
总成绩=(期末成绩);
}
}
class 实验成绩 extends 成绩{
ArrayList<Integer> 实验分数=new ArrayList<Integer>();
public 实验成绩(ArrayList<Integer> 实验分数) {
super();
this.实验分数 = 实验分数;
int sum=0;
for(int i=0;i<实验分数.size();i++) {
sum=实验分数.get(i)+sum;
}
总成绩=sum/实验分数.size();
}
}
class 选课{
学生 学生a;
String 课程a;
public 成绩 成绩a;
public 选课(学生 学生a, String 课程a, 成绩 成绩a) {
super();
this.学生a = 学生a;
this.课程a = 课程a;
this.成绩a = 成绩a;
}
}
class 输出{
ArrayList<课程>lesson;//课程信息
ArrayList <班级>classes;//班级信息
ArrayList <选课>choice;//课程学生成绩信息;
public 输出(ArrayList<课程> lesson, ArrayList<班级> classes, ArrayList<选课> choice) {
super();
this.lesson = lesson;
this.classes = classes;
this.choice = choice;
}
public void systemoutStudent() {//1）学生课程总成绩平均分按学号由低到高排序输出，格式：学号+英文空格+姓名+英文空格+总成绩平均分
for(int i=0;i<classes.size();i++) {
if(classes.get(i)!=null) {
Collections.sort(classes.get(i).students);
for(int k=0;k<classes.get(i).students.size();k++) {//一个班级里所有学生k的循环
int flag=1;//判断该学生是否有成绩
double sum=0;//每个学生的总成绩
double count=0;
for(int j=0;j<classes.get(i).xuanke.size();j++) {//一个班里期中一个学生k的所有选课成绩
if(classes.get(i).xuanke.get(j).学生a.学号.equals(classes.get(i).students.get(k).学号)) {
flag=0;
sum=sum+classes.get(i).xuanke.get(j).成绩a.总成绩;
count=count+1;
}
}
if(flag==1) {//如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
System.out.println(classes.get(i).students.get(k).学号+" "+classes.get(i).students.get(k).姓名+" "+"did not take any exams");
}
if(flag==0) {
System.out.println(classes.get(i).students.get(k).学号+" "+classes.get(i).students.get(k).姓名+" "+(int)Math.floor(sum/count));
classes.get(i).计算总成绩平均分(Math.floor(sum/count));
}
}
}
}
}
public void systemoutClasses() {//班级所有课程总成绩平均分按班级由低到高排序输出
for(int i=0;i<classes.size();i++) {
double sum=0;
int flagg=0;
for(int j=0;j<classes.get(i).xuanke.size();j++) {
flagg=1;
}
if(flagg==1) {//有sum班级名称+英文空格+ "has no grades yet"//班级号+英文空格+总成绩平均分
System.out.println(classes.get(i).班号+" "+(int)Math.floor(classes.get(i).sum/(double)classes.get(i).参与考试的人数));
}
if(flagg==0) {//该班级没有分数
System.out.println(classes.get(i).班号+" has no grades yet");
}
}
}
public void systemoutLesson() {//单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
//格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
//如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
for(int i=0;i<lesson.size();i++) {//遍历课程表
double 平时成绩=0;
double 期末成绩=0;
double 总成绩=0;
int flag=2;//判断该课程是否有成绩,2是没有,1是考试，0是考察
double count=0;//考试人数
课程 kc=lesson.get(i);//kc是某节课
for(int j=0;j<choice.size();j++) {//遍历选课信息,找到kc这堂课对应的成绩
if(choice.get(j).课程a.equals(kc.课程名称)) {
if(kc.考核方式.equals("考试")) {//找到之后，看对应的考核方式，考试的话就要累加平时成绩与期末成绩和总成绩
flag=1;
平时成绩=平时成绩+choice.get(j).成绩a.平时成绩;
期末成绩=期末成绩+choice.get(j).成绩a.期末成绩;
总成绩=总成绩+choice.get(j).成绩a.总成绩;
count++;
}
if(kc.考核方式.equals("考察")) {//考察,choice.get(j)是找到的对应kc的选课信息
flag=0;
总成绩=总成绩+choice.get(j).成绩a.总成绩;
count=count+1.0;
}
if(kc.考核方式.equals("实验")) {//考察,choice.get(j)是找到的对应kc的选课信息
flag=3;
总成绩=总成绩+choice.get(j).成绩a.总成绩;
count=count+1.0;
}
}
}
//格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
if(flag==0) {//考察
System.out.println(kc.课程名称+" "+(int)Math.floor(总成绩/count)+" "+(int)Math.floor(总成绩/count));
}
if(flag==1) {//考试
System.out.println(kc.课程名称+" "+(int)Math.floor(平时成绩/count)+" "+(int)Math.floor(期末成绩/count)+" "+(int)Math.floor(总成绩/count));
}
if(flag==3) {//实验
System.out.println(kc.课程名称+" "+(int)Math.floor(总成绩/count)+" "+(int)Math.floor(总成绩/count));
}
if(flag==2) {//没分！输出：课程名称+英文空格+"has no grades yet"
System.out.println(kc.课程名称+" has no grades yet");
}
}
}
}
类图：
圈复杂度：
分析：
设计正则表达式判断输入，要有几个判断输入格式的正则表达式，用.matches()方法来比较输入，用来.floor()来达到四舍五入的目的，还专门设计了一个 输出 类来控制输出。
动物发声模拟器（多态）
老实说，动物发声模拟器（多态）我兜兜转转也没用抽象方法实现，最终就是用了普通的继承（父子关系），但是因为一样可以实现而且输出结果正确，pta还是给我过了。抽象类、抽象方法还是不太用的明白，用对的那几次有点瞎猫碰着死耗子的感jio.
成绩统计程序-3
得分情况：
代码：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
Map<String,Student> students = new HashMap(); //学生列表
Map<String,Class> classMap=new HashMap<>(); //班级列表
Map<String, List<Course>> courses = new HashMap(); //key：课程名称，value：课程
String[] array = scan.nextLine().split(" ");
int arrayLength = array.length;
if (array[2].equals("考试")) {
if (array[1].equals("必修")) {
if(!courses.containsKey(array[0])) {
//考试课信息格式：课程名称+课程性质+考核方式+平时成绩的权重+期末成绩的权重
if (Integer.valueOf(3) != arrayLength - 4) {
System.out.println(array[0] + " : number of scores does not match");
return;
}
float weight = 0;
for (int i = 4; i < arrayLength; i++) {
weight += Double.valueOf(array[i]);
}
//如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
if (weight > 1.01) {
System.out.println(array[0] + " : weight value error");
return;
}
if (!courses.containsKey(array[0])) {
List<Course> courseList = courses.getOrDefault(array[0], new ArrayList<>());
courseList.add(new Course(array[0], array[1], array[2]));
courses.put(array[0], courseList);
}
while (true) {
String line = scan.nextLine();
if (line.equals("end")) {
break;
}
//考试/考查课程成绩信息格式：学号+姓名+课程名称+平时成绩+期末成绩
String[] value = line.split(" ");
int length = value.length;
//如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
if (courses.containsKey(value[2])) {
//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
if (length < 4) {
System.out.println(value[0] + " " + value[1] + " " + ": access mode mismatch");
//若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
if (!students.containsKey(value[0]) ||
!students.get(value[0]).getCourseSelections().containsKey(2)) {
String className = value[0].substring(0, 6);
Student student = students.getOrDefault(value[0], new Student(value[0], value[1], className));
Class classMsg = classMap.getOrDefault(className, new Class(className));
classMap.put(className, classMsg);
List<Course> courseList = courses.getOrDefault(value[2], new ArrayList<>());
double grade = -1.0;
student.updateCourseSelection(array[0], array[1], array[2], grade);
students.put(value[0], student);
classMsg.getStudents().put(student.getStudentId(), student);
courseList.add(new Course(value[2], array[1], array[2], grade));
courses.put(value[2], courseList);
}
continue;
}
//格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
if (!CheckGradeLegitimacy(value, 3)) {
System.out.println("wrong format");
return;
}
//若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
if (!students.containsKey(value[0]) ||
!students.get(value[0]).getCourseSelections().containsKey(2)) {
String className = value[0].substring(0, 6);
Student student = students.getOrDefault(value[0], new Student(value[0], value[1], className));
Class classMsg = classMap.getOrDefault(className, new Class(className));
List<Course> courseList = courses.getOrDefault(value[2], new ArrayList<>());
double grade = Double.valueOf(value[3]) * Double.valueOf(array[3]) +
Double.valueOf(value[4]) * Double.valueOf(array[4]);
student.updateCourseSelection(array[0], array[1], array[2], grade);
students.put(value[0], student);
classMsg.getStudents().put(student.getStudentId(), student);
classMap.put(className, classMsg);
courseList.add(new Course(value[2], array[1], array[2], grade));
courses.put(value[2], courseList);
}
} else {
System.out.println(value[0] + " " + value[1] + " " + ":" + value[2] + " " + "does not exist");
return;
}
}
}
} else {
System.out.println(array[0] + " : course type & access mode mismatch");
return;
}
} else if (array[2].equals("考察")) {
if (array[1].equals("选修")) {
//考察课信息格式：课程名称+课程性质+考核方式
if (!courses.containsKey(array[0])) {
List<Course> courseList=courses.getOrDefault(array[0],new ArrayList<>());
courseList.add( new Course(array[0], array[1], array[2]));
courses.put(array[0],courseList);
}
while (true) {
String line = scan.nextLine();
if (line.equals("end")) {
break;
}
//考试/考查课程成绩信息格式：学号+姓名+课程名称+平时成绩+期末成绩
String[] value = line.split(" ");
int length = value.length;
//如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
if (courses.containsKey(value[2])) {
//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
if(length<4){
System.out.println(value[0] + " " + value[1] + " " + ": access mode mismatch");
//若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
if(!students.containsKey(value[0]) ||
!students.get(value[0]).getCourseSelections().containsKey(2)){
String className=value[0].substring(0,6);
Student student=students.getOrDefault(value[0],new Student(value[0],value[1],className));
Class classMsg=classMap.getOrDefault(className,new Class(className));
classMap.put(className,classMsg);
List<Course> courseList=courses.getOrDefault(value[2],new ArrayList<>());
double grade=-1.0;
student.updateCourseSelection(array[0],array[1],array[2], grade);
students.put(value[0],student);
classMsg.getStudents().put(student.getStudentId(),student);
courseList.add(new Course(value[2],array[1],array[2],grade));
courses.put(value[2],courseList);
}
continue;
}
//格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
if(!CheckGradeLegitimacy(value,3)){
System.out.println("wrong format");
return;
}
//若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
if(!students.containsKey(value[0]) ||
!students.get(value[0]).getCourseSelections().containsKey(2)){
String className=value[0].substring(0,6);
Student student=students.getOrDefault(value[0],new Student(value[0],value[1],className));
Class classMsg=classMap.getOrDefault(className,new Class(className));
classMap.put(className,classMsg);
List<Course> courseList=courses.getOrDefault(value[2],new ArrayList<>());
double grade=Double.valueOf(value[3]);
student.updateCourseSelection(array[0],array[1],array[2], grade);
students.put(value[0],student);
classMsg.getStudents().put(student.getStudentId(),student);
courseList.add(new Course(value[2],array[1],array[2],grade));
courses.put(value[2],courseList);
}
} else {
System.out.println(value[0] + " " + value[1] + " " + ":" + value[2] + " " + "does not exist");
return;
}
}
} else {
System.out.println(array[0] + " : course type & access mode mismatch");
return;
}
} else if (array[2].equals("实验")) {
if (array[1].equals("实验")) {
if(!courses.containsKey(array[0])) {
//实验课程信息格式：课程名称+课程性质+考核方式+分项成绩数量n+分项成绩1的权重+。。。+分项成绩n的权重
//如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
if (Integer.valueOf(array[3]) != arrayLength - 4) {
System.out.println(array[0] + " : number of scores does not match");
return;
}
float weight = 0;
for (int i = 4; i < arrayLength; i++) {
weight += Double.valueOf(array[i]);
}
//如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
if (weight !=1.0) {
System.out.println(array[0] + " : weight value error");
return;
}
if (!courses.containsKey(array[0])) {
List<Course> courseList = courses.getOrDefault(array[0], new ArrayList<>());
courseList.add(new Course(array[0], array[1], array[2]));
courses.put(array[0], courseList);
}
while (true) {
String line = scan.nextLine();
if (line.equals("end")) {
break;
}
//实验课程信息格式：学号+姓名+课程名称+第一次实验成绩+...+最后一次实验成绩
String[] value = line.split(" ");
int length = value.length;
//如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
if (courses.containsKey(value[2])) {
//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
if (length - 3 != Integer.valueOf(array[3])) {
System.out.println(value[0] + " " + value[1] + " " + ": access mode mismatch");
//若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
if (!students.containsKey(value[0]) ||
!students.get(value[0]).getCourseSelections().containsKey(2)) {
String className = value[0].substring(0, 6);
Student student = students.getOrDefault(value[0], new Student(value[0], value[1], className));
Class classMsg = classMap.getOrDefault(className, new Class(className));
classMap.put(className, classMsg);
List<Course> courseList = courses.getOrDefault(value[2], new ArrayList<>());
double grade = -1.0;
student.updateCourseSelection(array[0], array[1], array[2], grade);
students.put(value[0], student);
classMsg.getStudents().put(student.getStudentId(), student);
courseList.add(new Course(value[2], array[1], array[2], grade));
courses.put(value[2], courseList);
}
continue;
}
//格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
if (!CheckGradeLegitimacy(value, 3)) {
System.out.println("wrong format");
return;
}
//若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
if (!students.containsKey(value[0]) ||
!students.get(value[0]).getCourseSelections().containsKey(2)) {
String className = value[0].substring(0, 6);
Student student = students.getOrDefault(value[0], new Student(value[0], value[1], className));
Class classMsg = classMap.getOrDefault(className, new Class(className));
classMap.put(className, classMsg);
List<Course> courseList = courses.getOrDefault(value[2], new ArrayList<>());
double grade = 0.0;
for (int i = 4, j = 3; i < arrayLength; i++, j++) {
grade += Double.valueOf(array[i]) * Double.valueOf(value[j]);
}
student.updateCourseSelection(array[0], array[1], array[2], grade);
students.put(value[0], student);
classMsg.getStudents().put(student.getStudentId(), student);
courseList.add(new Course(value[2], array[1], array[2], grade));
courses.put(value[2], courseList);
}
} else {
System.out.println(value[0] + " " + value[1] + " " + ":" + value[2] + " " + "does not exist");
return;
}
}
}
} else {
System.out.println(array[0] + " : course type & access mode mismatch");
}
}
// 输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
// 为避免四舍五入误差，
// 计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。
// 学生总成绩/整个班/课程平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
//学生课程总成绩平均分按学号由低到高排序输出
List<String> queue=new ArrayList<>(students.keySet());
Collections.sort(queue, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
for (String studentID:queue){
double grade=0.0;
int count=0;
for (CourseSelection selection: students.get(studentID).getCourseSelections().values()){
grade+=selection.getCourse().getGrade();
count++;
}
if(count>0 && grade>=0) {
//格式：学号+姓名+总成绩平均分
System.out.println(String.format("%s %s %d", studentID, students.get(studentID).getName(), (int)(grade / count)));
}
else {
System.out.println(String.format("%s %s did not take any exams", studentID, students.get(studentID).getName()));
}
}
//单门课程成绩按课程名称的字符顺序输出
queue=new ArrayList<>(courses.keySet());
Collections.sort(queue, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
for(String courseName:queue){
double grade=courses.values().size()>0?0:-1;
int count=-1;
for(Course course:courses.get(courseName)){
grade+=course.getGrade();
count++;
}
if(count>0 && grade>=0){
//格式：课程名称+总成绩平均分
System.out.println(String.format("%s %d",courseName,(int)(grade/count)));
}
else{
System.out.println(courseName+" has no grades yet");
}
}
//班级所有课程总成绩平均分按班级由低到高排序输出
queue=new ArrayList<>(classMap.keySet());
Collections.sort(queue, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
for(String className:queue){
float grade=0;
int count=0;
for (Student student:classMap.get(className).getStudents().values()){
for (CourseSelection selection:student.getCourseSelections().values()){
grade+=selection.getCourse().getGrade();
count++;
}
}
if(count>0 && grade>=0){
//班级号+英文空格+总成绩平均分
System.out.println(String.format("%s %d",className,(int)(grade/count)));
}
else {
System.out.println(className + " has no grades yet");
}
}
}
private static boolean CheckGradeLegitimacy(String[] value,int index){
int length= value.length;
//格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
for(int i=index;i<length;i++){
if(value[i].lastIndexOf(".")!=-1){
return false;
}
}
if(value[0].length()!=8 || value[1].length()>10 || value[2].length()>10){
return false;
}
return true;
}
}
class Student {
private String studentId; //学号
private String name; //姓名
private String className; //班级
private Map<String,CourseSelection> courseSelections; //选课
public Student(String studentId, String name, String className) {
this.studentId = studentId;
this.name = name;
this.className = className;
this.courseSelections = new HashMap<>();
}
public void updateCourseSelection(String courseName,String courseNature,String assessmentMethod,double grade){
CourseSelection selection=courseSelections.getOrDefault(
courseName,
new CourseSelection(
new Course(
courseName,
courseNature,
assessmentMethod
)));
selection.getCourse().setGrade(grade);
courseSelections.put(courseName,selection);
}
public String getStudentId() {
return studentId;
}
public void setStudentId(String studentId) {
this.studentId = studentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public Map<String, CourseSelection> getCourseSelections() {
return courseSelections;
}
public void setCourseSelections(Map<String, CourseSelection> courseSelections) {
this.courseSelections = courseSelections;
}
}
class CourseSelection {
private Course course; //课程
private CombinationGrade combinationGrade; //组合分项成绩
private CourseGrade courseGrade; //课程成绩
public CourseSelection(Course course){
this.course=course;
}
public CourseSelection(Course course, CombinationGrade combinationGrade) {
this.course = course;
this.combinationGrade=combinationGrade;
}
public CourseSelection(Course course ,CourseGrade courseGrade){
this.course=course;
this.courseGrade=courseGrade;
}
public Course getCourse() {
return course;
}
public void setCourse(Course course) {
this.course = course;
}
public CombinationGrade getCombinationGrade() {
return combinationGrade;
}
public void setCombinationGrade(CombinationGrade combinationGrade) {
this.combinationGrade = combinationGrade;
}
public CourseGrade getCourseGrade() {
return courseGrade;
}
public void setCourseGrade(CourseGrade courseGrade) {
this.courseGrade = courseGrade;
}
}
class Class {
private String className;
private Map<String,Student> students;
public Class(String className) {
this.className = className;
this.students = new HashMap<>();
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public Map<String, Student> getStudents() {
return students;
}
public void setStudents(Map<String, Student> students) {
this.students = students;
}
}
class Course {
private String courseName; //课程名称
private String courseNature; //性质（必修课、选修课、实验课）
private String assessmentMethod; //考核方式（考试、考察、实验）
private double grade; //分数
public Course(String courseName, String courseNature, String assessmentMethod) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMethod = assessmentMethod;
grade =0.0;
}
public Course(String courseName, String courseNature, String assessmentMethod,double grade) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMethod = assessmentMethod;
this.grade =grade;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public String getCourseNature() {
return courseNature;
}
public void setCourseNature(String courseNature) {
this.courseNature = courseNature;
}
public String getAssessmentMethod() {
return assessmentMethod;
}
public void setAssessmentMethod(String assessmentMethod) {
this.assessmentMethod = assessmentMethod;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
this.grade = grade;
}
}
class CombinationGrade {
private double[] grade;
private double[] weight;
private CombinationGrade(){
}
public CombinationGrade(double[] grade,double[] weight) {
this.grade=grade;
this.weight=weight;
}
public double[] getGrade() {
return grade;
}
public void setGrade(double[] grade) {
this.grade = grade;
}
public double[] getWeight() {
return weight;
}
public void setWeight(double[] weight) {
this.weight = weight;
}
}
class CourseGrade {
private int grade;
public CourseGrade(){
}
public CourseGrade(int grade) {
this.grade=grade;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
类图：
圈复杂度：
(绿色环形区域即被测量维度的期望值，维度上的点则是测量得到的实际值)
分析：
踩坑心得
❌ Java在数据类型这方面真的非常严格，自己不强制转换就不行（有几个单个测试点没过，后来听说是要用float而不能用double，不能理解）。
❌ 格式错误这个坑真的是屡踩不爽（细心和耐心真的很重要）。
❌ 要有好且持续的编程习惯（我经常因为记不太清，出现类名或者变量名大小写的错误，我决定要坚持用驼峰命名法，原因当然是因为应用广泛，当然，也算方便记忆，能避免我的一些错误）。
改进建议
✔️ 减少类与类之间的耦合度，便于迭代和删改。
✔️ 在某些方面增加题目的逻辑性和可读性，虽然以后如果要成为一名合格的程序员要有较强的理解能力，get到甲方的需求并满足他们的需求，但是现阶段还是很难做到的（啊喂）。
总结
学习写代码真的是一个持久且需要耐心的过程，要不断地练习，细心的查找错误，而这对于我个人而言，正是我比较欠缺的。除此之外，我还需要学习并掌握更多的编程技巧，包括错误处理、调试技巧、代码重构等，提高代码的质量和可读性，让我的代码更加简洁、易读、易于维护。
这个学期的面向对象程序设计的学习，在这次blog后也算是告一段落了，但是这并不意味着我们可以停止学习了，要抓住实训后的假期，加强学习，提升自己的能力，努力弯道赶上（人贵在有自知之明，超车应该是超不了了）。一起继续努力吧！
路漫漫其修远兮，吾将上下而求索
标签：String,int,value,public,Blog,new,Yqw,array From： https://www.cnblogs.com/1001love/p/17500498.html