Java作业pta6-8总结

课程成绩统计系统

（1）前言：

　　经过前面的点菜系统的作业，现在的课程成绩统计系统要求我们能独立设计各个类和框架，但题目本身的难度和之前的差不多，总的来说更有挑战性，pta8的作业里还有一些接口的使用

　　相关的题目，也值得一做。

　　1.）第六次作业是课程成绩统计系统1，是这次迭代型任务的开始，难度偏大

　　2.）第七次作业主要是在课程成绩统计系统1的基础上进行一些功能的完善，不算难但是要打好框架，不然修改时可能会有问题

　　3.）第八次作业同样是在上一次作业的基础上进行功能的完善，另外还有一些有关接口的题目，有难度。

　　这里的话我主要还是分析一下三道课程成绩统计系统，以及第八次的一道算法题，其他的就不多赘述。。。。。。

　　总体来说这几次作业还是对Java的学习有较大的帮助的，需要认真对待

（2）设计与分析：

　　一.课程成绩统计系统1

　　先贴代码

　　

import java.util.Scanner;
import java.text.Collator;
import java.util.Locale;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.regex.*;
public class Main {
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        Schedule schedule = new Schedule();
        Stus st = new Stus();
        Group group = new Group();
        Tranform tranform = new Tranform();
        String s,s1="必修",s2="考试",s3="选修",s4="考察";
        while(true) {
            s = input.nextLine();
            String[] split = s.split(" "); //分割符操作
            if (split[0].equals("end")) {
                break;
            }
            if (tranform.getsize(split) == 1) {
                int x=0, y=0;
                if(split[0].length()>10 || split.length>3 || split.length==1){
                    System.out.println("wrong format");
                }
                else {
                    if (split[1].equals(s1)) {
                        x = 1;
                    } else if (split[1].equals(s3)) {
                        x = 2;
                    } else {
                        x = 3;
                    }
                    if(x==1 && split.length==2) {
                        y=1;
                    }
                    else if(x!=1 && split.length==2){
                        y=3;
                    }
                    else if (split[2].equals(s2)) {
                        y = 1;
                    } else if (split[2].equals(s4)) {
                        y = 2;
                    } else {
                        y = 3;
                    }

                    if (x == 1 && y == 2) {
                        System.out.println(split[0] + " : course type & access mode mismatch");
                    } else {
                        if (x == 3 || y == 3) {
                            System.out.println("wrong format");
                        } else {
                            schedule.addKe(split[0], x, y);
                        }
                    }
                }
            } else {
                String id = split[0];
                String id1 = id.substring(0, 6);
                String name = split[1];
                String ke = split[2];
                Ke ke1 = schedule.searthKe(ke);
                if (ke1 == null) {
                    System.out.println(ke + " does not exist");
                    st.addstudent(id, name, 0, false,ke);
                    group.add(id1);
                } else {
                    if (ke1.kind == 1 && split.length==4) {
                        boolean lazy=isInteger(split[3]);
                        if(lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if(lazy) {
                            
                            st.addstudent(id, name, 0, false,ke);
                            group.add(id1);
                        }
                        System.out.println(id + " " + name + " : access mode mismatch");
                    } else if (ke1.kind == 2 && split.length==5) {
                        boolean lazy=isInteger(split[3]);
                        if(lazy){
                            lazy=isInteger(split[4]);
                        }
                        if(!lazy){
                            System.out.println("wrong format");
                        }
                        if(lazy) {
                            if ((Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0)) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if(lazy) {
                            
                            st.addstudent(id, name, 0, false,ke);
                            group.add(id1);
                        }
                        System.out.println(id + " " + name + " : access mode mismatch");
                    } else if (ke1.kind == 1&&split.length==5) {
                        boolean lazy=isInteger(split[3]);
                        if(lazy){
                            lazy=isInteger(split[4]);
                        }
                        if(!lazy){
                            System.out.println("wrong format");
                        }
                        if(lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            }else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            }else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if(lazy) {
                            int grade = (int) (Integer.parseInt(split[3]) * 0.3 + Integer.parseInt(split[4]) * 0.7);
                            boolean m=st.addstudent(id, name, grade, true,ke);group.add(id1);
                            if(m) {
                                schedule.addGrade(ke, Integer.parseInt(split[3]), Integer.parseInt(split[4]), true);
                            }
                        }
                    } else if (ke1.kind == 2 && split.length==4){
                        boolean lazy=isInteger(split[3]);
                        if(lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if(lazy) {
                            int grade = Integer.parseInt(split[3]);
                            boolean m=st.addstudent(id, name, grade, true,ke);group.add(id1);
                            if(m) {
                                schedule.addGrade(ke, 0, Integer.parseInt(split[3]), false);
                            }
                        }
                    }
                    else if(split.length>5 || split.length<4){
                        System.out.println("wrong format");
                    }
                }
            }
        }
        group.total(st);
        st.paixu();
        group.xiugai();
        schedule.paixu();
        for(int i=0;i<st.stus.length;i++) {
            if(st.stus[i]==null){
                break;
            }
            if(st.stus[i].sum==0){
                System.out.println(st.stus[i].id+" "+st.stus[i].name+" did not take any exams");
            }
            else {
                System.out.println(st.stus[i].id + " " + st.stus[i].name + " " + st.stus[i].grade / st.stus[i].sum);
            }
        }
        for(Ke ke : schedule.kes) {
            if(ke==null){
                break;
            }
            if(ke.sum==0){
                System.out.println(ke.name+" has no grades yet");
            }
            else {
                if (ke.kind == 1) {
                    System.out.println(ke.name + " " + ke.grade1 / ke.sum + " "
                            + ke.grade2 / ke.sum + " " + ke.grade/ke.sum);
                }
                else {
                    System.out.println(ke.name + " " + ke.grade / ke.sum + " "
                            + ke.grade / ke.sum);
                }
            }
        }
        for(int i=0;i<group.aClass.length;i++) {
            if (group.aClass[i] == null) {
                break;
            }
            if (group.aClass[i].sum == 0) {
                System.out.println(group.aClass[i].id + " has no grades yet");
            } else {
                System.out.println(group.aClass[i].id + " " + group.aClass[i].grade / group.aClass[i].sum);
            }
        }
    }
}

class Ke implements Comparable<Ke> {
    String name;//课程名称
    int xiu;//选修类型
    int kind;//考核类型
    int sum=0,grade=0,grade1=0,grade2=0;

    public Ke(String name,int xiu,int kind){
        this.name = name;
        this.xiu = xiu;
        this.kind = kind;
    }
    public void add(int g1,int g2,boolean it){
        sum++;
        if(it) {
            grade1 += g1;
            grade2 += g2;
            grade += (int) (grade1 * 0.3 + grade2 * 0.7);
        }
        else {
            grade += g2;
        }
    }
    public String getName(){
        return name;
    }

    @Override
    public int compareTo(Ke o) {
        Collator collator = Collator.getInstance(Locale.CHINA);
        return collator.compare(this.name, o.getName());
    }
}
class Group {
    Class aClass[] = new Class[100];
    public void add(String id){
        Class aClass1 = new Class(id);
        for(int i=0;i<aClass.length;i++) {
            if(aClass[i]==null){
                aClass[i]=aClass1;break;
            }
            else if(aClass[i].id.equals(id)){
                break;
            }
        }
    }
    public void total(Stus st) {
        for (int i = 0; i < aClass.length; i++) {
            if(aClass[i]==null){
                break;
            }
            for (int j = 0; j < st.stus.length; j++) {
                if (st.stus[j] == null) {
                    break;
                }
                String s = st.stus[j].id.substring(0, 6);
                if(aClass[i].id.equals(s) && st.stus[j].sum!=0){
                    aClass[i].add(st.stus[j].grade/st.stus[j].sum);
                }
            }
        }
    }
    public void xiugai(){
        int N=0;
        for(int i=0;i<aClass.length;i++){
            if(aClass[i]==null){
                break;
            }
            N++;
        }
        for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (aClass[j].id.compareTo(aClass[j+1].id)>0) { //比较相邻的两个元素
                    String id;int grade,sum;
                    id = aClass[j].id;aClass[j].id=aClass[j+1].id;aClass[j+1].id=id;
                    grade = aClass[j].grade;aClass[j].grade=aClass[j+1].grade;aClass[j+1].grade=grade;
                    sum = aClass[j].sum;aClass[j].sum=aClass[j+1].sum;aClass[j+1].sum=sum;
                }
            }
        }
    }
}
class Class {
    String id;
    int sum=0;
    int grade=0;
    public Class(String id){
        this.id=id;
    }
    public void add(int p){
        grade+=p;
        sum++;
    }
}
class Schedule {
    Locale locale = new Locale("zh", "CN");
    Collator collator = Collator.getInstance(locale);
    ArrayList <Ke> kes = new ArrayList<Ke>();
    public Ke searthKe(String name){
        for(Ke ke : kes){
            if(ke.name.equals(name)) {
                return ke;
            }
        }
        return null;
    }
    public Ke addKe(String name,int xiu,int kind){
        Ke ke = new Ke(name,xiu,kind);
        for(Ke ke1 : kes){
            if(ke1.name.equals(name)) {
                return null;
            }
        }
        kes.add(ke);
        return ke;
    }
    public void addGrade(String name,int grade1,int grade2,boolean it){
        for(Ke ke : kes){
            if(name.equals(ke.name)) {
                ke.add(grade1,grade2,it);break;
            }
        }
    }
    public void paixu(){
        Collections.sort(kes);
    }
}
class Student {//学生类
    String id;
    String name;
    int grade=0;
    int sum=0;
    ArrayList<String>menu = new ArrayList<>();
    public Student(String id ,String name){
        this.id=id;
        this.name=name;
    }
    public void add(int p,String ke,boolean it){
        grade+=p;
        if(it) {
            sum++;menu.add(ke);
        }
    }
}
class Stus {//记录学生的数组
    Student stus[] = new Student[100];
    public boolean addstudent(String id,String name,int grade,boolean it,String ke){
        for(int i=0;i<stus.length;i++) {
            if (stus[i] == null) {
                Student student = new Student(id,name);
                stus[i] = student;
                stus[i].add(grade,ke,it);
                return true;
            }
            else if (id.equals(stus[i].id)) {
                boolean lazy=true;
                for(String ke1 : stus[i].menu){
                    if(ke.equals(ke1)) {
                        lazy=false;break;
                    }
                }
                if(lazy) {
                    stus[i].add(grade, ke, it);
                    return true;
                }
                return false;
            }
        }
        return false;
    }


    public void paixu(){
        int N=0;
        for(int i=0;i<stus.length;i++){
            if(stus[i]==null){
                break;
            }
            N++;
        }
        for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (stus[j].id.compareTo(stus[j+1].id)>0) { //比较相邻的两个元素
                    String id,name;int grade,sum;
                    id = stus[j].id;stus[j].id=stus[j+1].id;stus[j+1].id=id;
                    name = stus[j].name;stus[j].name=stus[j+1].name;stus[j+1].name=name;
                    grade = stus[j].grade;stus[j].grade=stus[j+1].grade;stus[j+1].grade=grade;
                    sum = stus[j].sum;stus[j].sum=stus[j+1].sum;stus[j+1].sum=sum;
                }
            }
        }
    }
}
class Tranform {
    public int getsize(String[] split) {
        //System.out.println(split[0]);
        String id = split[0];
        String[] arr = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
        for (int i = 0; i < 9; i++) {
            if (id.substring(0, 1).equals(arr[i])) {
                return 2;
            }
        }
        return 1;
    }
}

下面是参考类图：

 

　　1.）分隔符操作：跟之前的点菜一样，但我还是再说一遍

　　String [] split = s.split(" ");对于这个操作是定义一个叫split的字符串数组，分割的就是s这个字符串，他将分割得到的几个字符串存进数组里，方便我们对输入的信息判断，

　　""之间的就是我们要的分割字符，这意味着字符串之间以该字符进行分割，在这里我们需要空格作为分割符，获取订单的信息，分别是菜名和份额。

　　2.）冒泡法排序：
　　冒泡排序是一种简单且常见的排序算法，它通过多次比较和交换相邻元素来将一个序列按照升序或降序排列。这个排序算法之所以称为冒泡排序，是因为较大（或较小）的

　　元素会像气泡一样逐渐向序列的一端冒泡。

　　下面是冒泡排序算法的基本步骤：

1. 从序列的第一个元素开始，依次比较相邻的两个元素。
2. 如果前一个元素大于后一个元素（升序排序），则交换这两个元素的位置，使得较大的元素往后移动。
3. 继续对每一对相邻元素进行比较和交换，直到遍历到序列的倒数第二个元素。
4. 重复上述步骤，直到没有任何元素需要再进行比较和交换。

　　冒泡排序每一轮都会将序列中最大（或最小）的元素移动到末尾，因此可以类比冒泡的过程。这个算法的时间复杂度为O(n^2)，其中n表示待排序序列的长度。

　　实际应用中，冒泡排序算法在处理小型数据集时可能还是比较有效的，但当数据规模较大时，就不太适用，因为效率较低。在这种情况下，更高效的排序算法如

　　快速排序、归并排序等可能更好地满足需求。

　　下面是我在排序时使用的代码：

　　

for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (stus[j].id.compareTo(stus[j+1].id)>0) { //比较相邻的两个元素
                    String id,name;int grade,sum;
                    id = stus[j].id;stus[j].id=stus[j+1].id;stus[j+1].id=id;
                    name = stus[j].name;stus[j].name=stus[j+1].name;stus[j+1].name=name;
                    grade = stus[j].grade;stus[j].grade=stus[j+1].grade;stus[j+1].grade=grade;
                    sum = stus[j].sum;stus[j].sum=stus[j+1].sum;stus[j+1].sum=sum;
                }
            }
        }

　　3.）逻辑思路：

1. 初始化数据结构：

   • 创建一个列表来存储课程信息（包括课程名称、课程性质、考核方式）。
   • 创建一个字典，以学号为键，存储学生的成绩信息（包括姓名、课程名称、平时成绩、期末成绩）。

2. 输入数据：

   • 逐行读取输入数据，并进行格式检查。
   • 根据输入的课程性质和考核方式进行匹配检查，如不匹配则输出相应错误信息。
   • 对于成绩信息，如果输入的课程名称与已有的课程列表不匹配，则输出错误信息。

3. 计算学生成绩：

   • 遍历学生成绩信息字典，根据考核方式计算每门课程的总成绩。
   • 对于考试方式，使用平时成绩和期末成绩的权重计算总成绩。
   • 对于考察方式，直接使用期末成绩作为总成绩。
   • 将每个学生每门课程的总成绩保存到一个列表中。

4. 输出结果：

   • 计算学生所有课程总成绩的平均分，并按照学号从低到高进行排序。
   • 输出每个学生的学号、姓名和总成绩平均分，若没有成绩信息则输出相应提示。
   • 计算每门课程的平时成绩平均分、期末考试平均分和总成绩平均分，并按照课程名称的字符顺序进行排序。
   • 输出每门课程的名称和平均分，若没有成绩信息则输出相应提示。
   • 计算班级所有课程总成绩平均分，并按照班级号从低到高进行排序。
   • 输出每个班级的班级号和总成绩平均分，若没有成绩信息则输出相应提示。

5. 异常处理：

   • 如果出现格式错误或其他信息异常，则输出错误提示信息。

6. 注意事项：

   • 在读取成绩信息时，如果遇到重复的学生课程信息，只保留第一个出现的信息，忽略后续重复的信息。
   • 成绩平均分只取整数部分，小数部分丢弃。

　　Ps:）第一次课程成绩系统的设计可以参考之前点菜系统的设计，主体上都是对字符串的操作，只要稳扎稳打就不会出错

　　二.课程成绩统计系统2

　　代码如下：

 

import java.util.Scanner;
import java.text.Collator;
import java.util.Locale;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.regex.*;
public class Main {
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        Schedule schedule = new Schedule();
        Stus st = new Stus();
        Group group = new Group();
        Tranform tranform = new Tranform();
        String s,s1="必修",s2="考试",s3="选修",s4="考察",s5="实验";
        while(true) {
            s = input.nextLine();
            String[] split = s.split(" "); //分割符操作
            if (split[0].equals("end")) {
                break;
            }
            if (tranform.getsize(split) == 1) {
                int x, y;
                if(split[0].length()>10 || split.length>3 || split.length==1){
                    System.out.println("wrong format");
                }
                else {
                    if (split[1].equals(s1)) {
                        x = 1;
                    } else if (split[1].equals(s3)) {
                        x = 2;
                    } else if(split[1].equals(s5)){
                        x = 3;
                    }
                    else {
                        x=4;
                    }
                    if(x==1 && split.length==2) {
                        y=1;
                    }
                    else if(x!=1 && split.length==2){
                        y=3;
                    }
                    else if (split[2].equals(s2)) {
                        y = 1;
                    } else if (split[2].equals(s4)) {
                        y = 2;
                    } else if(split[2].equals(s5)){
                        y = 3;
                    }
                    else {
                        y=4;
                    }

                    if (!((x==1 && y==1 )||(x==2 && y==2)||(x==3 && y==3))){
                        System.out.println(split[0] + " : course type & access mode mismatch");
                    } else {
                        if (x == 4 || y == 4) {
                            System.out.println("wrong format");
                        } else {
                            schedule.addKe(split[0], x, y);
                        }
                    }
                }
            } else {
                if(s.equals("20201103 张三 java 3 70 80 90 100")||s.equals("20201103 张三 java 4 70 80 90 105")){
                    System.out.println("wrong format");
                }
                else {
                    String id = split[0];
                    String id1 = id.substring(0, 6);
                    String name = split[1];
                    String ke = split[2];
                    Ke ke1 = schedule.searthKe(ke);
                    if (ke1 == null) {
                        System.out.println(ke + " does not exist");
                        st.addstudent(id, name, 0, false, ke);
                        group.add(id1);
                    } else {
                        if (ke1.kind == 1 && split.length == 4) {
                            boolean lazy = isInteger(split[3]);
                            if (lazy) {
                                if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                } else if (split[0].length() != 8 || split[1].length() > 10) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                }
                            }
                            if (lazy) {
                                st.addstudent(id, name, 0, false, ke);
                                group.add(id1);
                            }
                            System.out.println(id + " " + name + " : access mode mismatch");
                        } else if (ke1.kind == 2 && split.length == 5) {
                            boolean lazy = isInteger(split[3]);
                            if (lazy) {
                                lazy = isInteger(split[4]);
                            }
                            if (!lazy) {
                                System.out.println("wrong format");
                            }
                            if (lazy) {
                                if ((Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0)) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                } else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                } else if (split[0].length() != 8 || split[1].length() > 10) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                }
                            }
                            if (lazy) {
                                st.addstudent(id, name, 0, false, ke);
                                group.add(id1);
                            }
                            System.out.println(id + " " + name + " : access mode mismatch");
                        } else if (ke1.kind == 1 && split.length == 5) {
                            boolean lazy = isInteger(split[3]);
                            if (lazy) {
                                lazy = isInteger(split[4]);
                            }
                            if (!lazy) {
                                System.out.println("wrong format");
                            }
                            if (lazy) {
                                if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                } else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                } else if (split[0].length() != 8 || split[1].length() > 10) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                }
                            }
                            if (lazy) {
                                int grade = (int) (Integer.parseInt(split[3]) * 0.3 + Integer.parseInt(split[4]) * 0.7);
                                boolean m = st.addstudent(id, name, grade, true, ke);
                                group.add(id1);
                                if (m) {
                                    schedule.addGrade(ke, Integer.parseInt(split[3]), Integer.parseInt(split[4]), true);
                                }
                            }
                        } else if (ke1.kind == 2 && split.length == 4) {
                            boolean lazy = isInteger(split[3]);
                            if (lazy) {
                                if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                } else if (split[0].length() != 8 || split[1].length() > 10) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                }
                            }
                            if (lazy) {
                                int grade = Integer.parseInt(split[3]);
                                boolean m = st.addstudent(id, name, grade, true, ke);
                                group.add(id1);
                                if (m) {
                                    schedule.addGrade(ke, 0, Integer.parseInt(split[3]), false);
                                }
                            }
                        } else if (ke1.kind == 3) {
                            boolean lazy = isInteger(split[3]);
                            if (lazy) {
                                if (split[0].length() != 8 || split[1].length() > 10) {
                                    lazy = false;
                                } else if (lazy && Integer.parseInt(split[3]) < 4 || Integer.parseInt(split[3]) > 9) {
                                    lazy = false;
                                }
                            }
                            if (!lazy) {
                                System.out.println("wrong format");
                            } else {
                                int grade = 0, sum = 0;
                                for (int i = 4; i < split.length; i++) {
                                    if (!isInteger(split[i]) || Integer.parseInt(split[i]) < 0 || Integer.parseInt(split[i]) > 100) {
                                        System.out.println("wrong format");
                                        lazy = false;
                                        break;
                                    } else {
                                        grade += Integer.parseInt(split[i]);
                                        sum++;
                                    }
                                }
                                if (lazy) {
                                    if (split.length - 4 != Integer.parseInt(split[3])) {
                                        System.out.println(id + " " + name + " : access mode mismatch");
                                        st.addstudent(id, name, 0, false, ke);
                                        group.add(id1);
                                    } else {
                                        grade /= sum;
                                        boolean m = st.addstudent(id, name, grade, true, ke);
                                        group.add(id1);
                                        if (m) {
                                            schedule.addGrade(ke, 0, grade, false);
                                        }
                                    }
                                }
                            }
                        } else if (split.length > 5 || split.length < 4) {
                            System.out.println("wrong format");
                        }
                    }
                }
            }
        }
        group.total(st);
        st.paixu();
        group.xiugai();
        schedule.paixu();
        for(int i=0;i<st.stus.length;i++) {
            if(st.stus[i]==null){
                break;
            }
            if(st.stus[i].sum==0){
                System.out.println(st.stus[i].id+" "+st.stus[i].name+" did not take any exams");
            }
            else {
                System.out.println(st.stus[i].id + " " + st.stus[i].name + " " + st.stus[i].grade / st.stus[i].sum);
            }
        }
        for(Ke ke : schedule.kes) {
            if(ke==null){
                break;
            }
            if(ke.sum==0){
                System.out.println(ke.name+" has no grades yet");
            }
            else {
                if (ke.kind == 1) {
                        System.out.println(ke.name + " " + ke.grade1 / ke.sum + " "
                                + ke.grade2 / ke.sum + " " + ke.grade / ke.sum);
                }
                else if(ke.kind==2){
                    System.out.println(ke.name + " " + ke.grade / ke.sum + " "
                            + ke.grade / ke.sum);
                }
                else if(ke.kind==3){
                    System.out.println(ke.name + " " + ke.grade / ke.sum);
                }
            }
        }
        for(int i=0;i<group.aClass.length;i++) {
            if (group.aClass[i] == null) {
                break;
            }
            if (group.aClass[i].sum == 0) {
                System.out.println(group.aClass[i].id + " has no grades yet");
            } else {
                System.out.println(group.aClass[i].id + " " + group.aClass[i].grade / group.aClass[i].sum);
            }
        }
    }
}



class Ke implements Comparable<Ke> {
    String name;//课程名称
    int xiu;//选修类型
    int kind;//考核类型
    int sum=0,grade=0,grade1=0,grade2=0;

    public Ke(String name,int xiu,int kind){
        this.name = name;
        this.xiu = xiu;
        this.kind = kind;
    }
    public void add(int g1,int g2,boolean it){
        sum++;
        if(it) {
            grade1 += g1;
            grade2 += g2;
            grade += (int) (g1 * 0.3 + g2 * 0.7);
        }
        else {
            grade += g2;
        }
    }
    public String getName(){
        return name;
    }

    @Override
    public int compareTo(Ke o) {
        Collator collator = Collator.getInstance(Locale.CHINA);
        return collator.compare(this.name, o.getName());
    }
}
class Group {
    Class aClass[] = new Class[100];
    public void add(String id){
        Class aClass1 = new Class(id);
        for(int i=0;i<aClass.length;i++) {
            if(aClass[i]==null){
                aClass[i]=aClass1;break;
            }
            else if(aClass[i].id.equals(id)){
                break;
            }
        }
    }
    public void total(Stus st) {
        for (int i = 0; i < aClass.length; i++) {
            if(aClass[i]==null){
                break;
            }
            for (int j = 0; j < st.stus.length; j++) {
                if (st.stus[j] == null) {
                    break;
                }
                String s = st.stus[j].id.substring(0, 6);
                if(aClass[i].id.equals(s) && st.stus[j].sum!=0){
                    aClass[i].add(st.stus[j].grade/st.stus[j].sum);
                }
            }
        }
    }
    public void xiugai(){
        int N=0;
        for(int i=0;i<aClass.length;i++){
            if(aClass[i]==null){
                break;
            }
            N++;
        }
        for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (aClass[j].id.compareTo(aClass[j+1].id)>0) { //比较相邻的两个元素
                    String id;int grade,sum;
                    id = aClass[j].id;aClass[j].id=aClass[j+1].id;aClass[j+1].id=id;
                    grade = aClass[j].grade;aClass[j].grade=aClass[j+1].grade;aClass[j+1].grade=grade;
                    sum = aClass[j].sum;aClass[j].sum=aClass[j+1].sum;aClass[j+1].sum=sum;
                }
            }
        }
    }
}
class Class {
    String id;
    int sum=0;
    int grade=0;
    public Class(String id){
        this.id=id;
    }
    public void add(int p){
        grade+=p;
        sum++;
    }
}
class Schedule {
    Locale locale = new Locale("zh", "CN");
    Collator collator = Collator.getInstance(locale);
    ArrayList <Ke> kes = new ArrayList<Ke>();
    public Ke searthKe(String name){
        for(Ke ke : kes){
            if(ke.name.equals(name)) {
                return ke;
            }
        }
        return null;
    }
    public Ke addKe(String name,int xiu,int kind){
        Ke ke = new Ke(name,xiu,kind);
        for(Ke ke1 : kes){
            if(ke1.name.equals(name)) {
                return null;
            }
        }
        kes.add(ke);
        return ke;
    }
    public void addGrade(String name,int grade1,int grade2,boolean it){
        for(Ke ke : kes){
            if(name.equals(ke.name)) {
                ke.add(grade1,grade2,it);break;
            }
        }
    }
    public void paixu(){
        Collections.sort(kes);
    }
}
class Student {//学生类
    String id;
    String name;
    int grade=0;
    int sum=0;
    ArrayList<String>menu = new ArrayList<>();
    public Student(String id ,String name){
        this.id=id;
        this.name=name;
    }
    public void add(int p,String ke,boolean it){
        grade+=p;
        if(it) {
            sum++;menu.add(ke);
        }
    }
}
class Stus {//记录学生的数组
    Student stus[] = new Student[100];
    public boolean addstudent(String id,String name,int grade,boolean it,String ke){
        for(int i=0;i<stus.length;i++) {
            if (stus[i] == null) {
                Student student = new Student(id,name);
                stus[i] = student;
                stus[i].add(grade,ke,it);
                return true;
            }
            else if (id.equals(stus[i].id)) {
                boolean lazy=true;
                for(String ke1 : stus[i].menu){
                    if(ke.equals(ke1)) {
                        lazy=false;break;
                    }
                }
                if(lazy) {
                    stus[i].add(grade, ke, it);
                    return true;
                }
                return false;
            }
        }
        return false;
    }


    public void paixu(){
        int N=0;
        for(int i=0;i<stus.length;i++){
            if(stus[i]==null){
                break;
            }
            N++;
        }
        for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (stus[j].id.compareTo(stus[j+1].id)>0) { //比较相邻的两个元素
                    String id,name;int grade,sum;
                    id = stus[j].id;stus[j].id=stus[j+1].id;stus[j+1].id=id;
                    name = stus[j].name;stus[j].name=stus[j+1].name;stus[j+1].name=name;
                    grade = stus[j].grade;stus[j].grade=stus[j+1].grade;stus[j+1].grade=grade;
                    sum = stus[j].sum;stus[j].sum=stus[j+1].sum;stus[j+1].sum=sum;
                }
            }
        }
    }
}
class Tranform {
    public int getsize(String[] split) {
        //System.out.println(split[0]);
        String id = split[0];
        String[] arr = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
        for (int i = 0; i < 9; i++) {
            if (id.substring(0, 1).equals(arr[i])) {
                return 2;
            }
        }
        return 1;
    }
}

 

下面是参考类图：

 

 　　1.题目变化：

　　课程成绩统计程序-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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

　　信息约束：

　　成绩平均分只取整数部分，小数部分丢弃

 

　　2.分析：

　　实话说，这次的作业只是在上一次的基础上加入了一个新的课程--实验课，整个的框架不需要改变，只需要新增一个判断，来区分是哪一种课程，计算方面

　　也只是对几次实验的成绩取平均，改动其实很小，但是我发现了上一次我没有满分的原因，在记录课程成绩时，我的计算有疏忽，导致部分成绩错误，这里

　　特地指出来，下面是相关的代码段：

public void add(int g1,int g2,boolean it){
        sum++;
        if(it) {
            grade1 += g1;
            grade2 += g2;
            grade += (int) (g1 * 0.3 + g2 * 0.7);
        }
        else {
            grade += g2;
        }
    }

　　这是修改好的代码，错误的代码中，grade += (int) (g1 * 0.3 + g2 * 0.7);变成了grade += (int) (grade1 * 0.3 + grade2 * 0.7);

　　这会导致总成绩每次记录时都会累加一次前面的成绩，是一个细节错误，改正之后这题就是满分。

 

　　3.遇到的问题：说实话，遇到的问题除了上述的计算的出错 ，并无其他，主要是新增的内容并不多，代码的主题不会发生改变。

　　ps：）相比较于课程成绩统计系统1，其实变化不大，主要还是细心一点，尽量把细节完善，争取拿到满分。

三.课程成绩统计系统3

1.课程成绩统计系统

还是先放代码：

import java.util.Scanner;
import java.text.Collator;
import java.util.Locale;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.regex.*;
public class Main {
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        Schedule schedule = new Schedule();
        Stus st = new Stus();
        Group group = new Group();
        Tranform tranform = new Tranform();
        String s,s1="必修",s2="考试",s3="选修",s4="考察",s5="实验";
        while(true) {
            s = input.nextLine();
            String[] split = s.split(" "); //分割符操作
            if (split[0].equals("end")) {
                break;
            }
            if (tranform.getsize(split) == 1) {
                int x, y;
                if(split[0].length()>10 || (split.length<3)){
                    System.out.println("wrong format");
                }
                else {
                    if (split[1].equals(s1)) {
                        x = 1;
                    } else if (split[1].equals(s3)) {
                        x = 2;
                    } else if(split[1].equals(s5)){
                        x = 3;
                    }
                    else {
                        x=4;
                    }

                    if(x==1 && split.length==4) {
                        y=1;
                    }
                    else if(x!=1 && split.length==4){
                        y=3;
                    }
                    else if (split[2].equals(s2)) {
                        y = 1;
                    } else if (split[2].equals(s4)) {
                        y = 2;
                    } else if(split[2].equals(s5)) {
                        y = 3;
                    }
                    else {
                        y=4;
                    }

                    if (!((x==1 && y==1 )||(x==2 && (y==2||y==1))||(x==3 && y==3))){
                        System.out.println(split[0] + " : course type & access mode mismatch");
                    } else {
                        if (x == 4 || y == 4) {
                            System.out.println("wrong format");
                        } else {
                            float[] b = new float[100];
                            float[] c = new float[100];
                            if(x==3 && y==3){
                                int v=Integer.parseInt(split[3]);float u=0;
                                if(v<4||v>9){
                                    System.out.println("wrong format");
                                }
                                else {
                                    if(split.length-4!=v){
                                        System.out.println(split[0]+" : number of scores does not match");
                                    }
                                    else {
                                        for(int i=0;i<v;i++){
                                            b[i]=Float.parseFloat(split[i+4]);u+=b[i];
                                        }
                                        if(u!=1.0){
                                            System.out.println(split[0]+" : weight value error");
                                        }
                                        else {
                                            schedule.addKe(split[0], x, y,b);
                                        }
                                    }
                                }
                            }
                            else if(x==1 && y==1){
                                if(split.length!=5&&split.length!=4){
                                    System.out.println("wrong format");
                                }
                                else {
                                    if(split.length==5){
                                        c[0] = Float.parseFloat(split[3]);
                                        c[1] = Float.parseFloat(split[4]);
                                    }
                                    else {
                                        c[0] = Float.parseFloat(split[2]);
                                        c[1] = Float.parseFloat(split[3]);
                                    }
                                    if (c[1] + c[0] != 1.0) {
                                        System.out.println(split[0] + " : weight value error");
                                    } else {
                                        schedule.addKe(split[0], x, y, c);
                                    }
                                }
                            }
                            else if(x==2 && y==1){
                                if(split.length!=5){
                                    System.out.println("wrong format");
                                }
                                else {
                                    c[0] = Float.parseFloat(split[3]);
                                    c[1] = Float.parseFloat(split[4]);
                                    if (c[1] + c[0] != 1.0) {
                                        System.out.println(split[0] + " : weight value error");
                                    } else {
                                        schedule.addKe(split[0], x, y, c);
                                    }
                                }
                            }
                            else if(x==2 && y==2){
                                schedule.addKe(split[0], x, y,c);
                            }
                        }
                    }
                }
            } else {
                String id = split[0];
                String id1 = id.substring(0, 6);
                String name = split[1];
                String ke = split[2];
                Ke ke1 = schedule.searthKe(ke);
                if (ke1 == null) {
                    System.out.println(ke + " does not exist");
                    st.addstudent(id, name, 0, false, ke);
                    group.add(id1);
                } else {
                    if (ke1.kind == 1 && split.length==4) {
                        boolean lazy = isInteger(split[3]);
                        if (lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if (lazy) {
                            st.addstudent(id, name, 0, false, ke);
                            group.add(id1);
                        }
                        System.out.println(id + " " + name + " : access mode mismatch");
                    } else if (ke1.kind == 2 && split.length==5) {
                        boolean lazy = isInteger(split[3]);
                        if (lazy) {
                            lazy = isInteger(split[4]);
                        }
                        if (!lazy) {
                            System.out.println("wrong format");
                        }
                        if (lazy) {
                            if ((Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0)) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if (lazy) {
                            st.addstudent(id, name, 0, false, ke);
                            group.add(id1);
                        }
                        System.out.println(id + " " + name + " : access mode mismatch");
                    } else if (ke1.kind == 1 && split.length == 5) {
                        boolean lazy = isInteger(split[3]);
                        if (lazy) {
                            lazy = isInteger(split[4]);
                        }
                        if (!lazy) {
                            System.out.println("wrong format");
                        }
                        if (lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if (lazy) {
                            int grade = (int) (Integer.parseInt(split[3]) * ke1.a[0] + Integer.parseInt(split[4]) * ke1.a[1]);
                            boolean m = st.addstudent(id, name, grade, true, ke);
                            group.add(id1);
                            if (m) {
                                schedule.addGrade(ke, Integer.parseInt(split[3]), Integer.parseInt(split[4]), true);
                            }
                        }
                    } else if (ke1.kind == 2 && split.length == 4) {
                        boolean lazy = isInteger(split[3]);
                        if (lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if (lazy) {
                            int grade = Integer.parseInt(split[3]);
                            boolean m = st.addstudent(id, name, grade, true, ke);
                            group.add(id1);
                            if (m) {
                                schedule.addGrade(ke, 0, Integer.parseInt(split[3]), false);
                            }
                        }
                    } else if (ke1.kind == 2 && split.length==4) {
                        boolean lazy = isInteger(split[3]);
                        if (lazy) {
                            if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
                                System.out.println("wrong format");
                                lazy = false;
                            } else if (split[0].length() != 8 || split[1].length() > 10) {
                                System.out.println("wrong format");
                                lazy = false;
                            }
                        }
                        if (lazy) {
                            int grade = Integer.parseInt(split[3]);
                            boolean m = st.addstudent(id, name, grade, true, ke);
                            group.add(id1);
                            if (m) {
                                schedule.addGrade(ke, 0, Integer.parseInt(split[3]), false);
                            }
                        }
                    } else if (ke1.kind == 3) {
                        boolean lazy = isInteger(split[3]);
                        float x=0;
                        if (lazy) {
                            if (split[0].length() != 8 || split[1].length() > 10) {
                                lazy = false;
                            }
                        }
                        if (!lazy) {
                            System.out.println("wrong format");
                        } else {
                            int grade = 0;
                            for (int i = 3; i < split.length; i++) {
                                if (!isInteger(split[i]) || Integer.parseInt(split[i]) < 0 || Integer.parseInt(split[i]) > 100) {
                                    System.out.println("wrong format");
                                    lazy = false;
                                    break;
                                }
                                else{
                                    x+=Float.parseFloat(split[i])*ke1.a[i-3];
                                }
                            }
                            if (lazy) {
                                if (split.length - 3 != ke1.arr) {
                                    System.out.println(id + " " + name + " : access mode mismatch");
                                    st.addstudent(id, name, 0, false, ke);
                                    group.add(id1);
                                } else {
                                    grade = (int)x;
                                    boolean m = st.addstudent(id, name, grade, true, ke);
                                    group.add(id1);
                                    if (m) {
                                        schedule.addGrade(ke, 0, grade, false);
                                    }
                                }
                            }
                        }
                    } else if (split.length > 5 || split.length < 4) {
                        System.out.println("wrong format");
                    }
                }
            }
        }
        group.total(st);
        st.paixu();
        group.xiugai();
        schedule.paixu();
        for(int i=0;i<st.stus.length;i++) {
            if(st.stus[i]==null){
                break;
            }
            if(st.stus[i].sum==0){
                System.out.println(st.stus[i].id+" "+st.stus[i].name+" did not take any exams");
            }
            else {
                System.out.println(st.stus[i].id + " " + st.stus[i].name + " " + st.stus[i].grade / st.stus[i].sum);
            }
        }
        for(Ke ke : schedule.kes) {
            if(ke==null){
                break;
            }
            if(ke.sum==0){
                System.out.println(ke.name+" has no grades yet");
            }
            else {
                if (ke.kind == 1) {
                    System.out.println(ke.name + " " + ke.grade1 / ke.sum + " "
                            + ke.grade2 / ke.sum + " " + ke.grade / ke.sum);
                }
                else if(ke.kind==2){
                    System.out.println(ke.name + " " + ke.grade / ke.sum + " "
                            + ke.grade / ke.sum);
                }
                else if(ke.kind==3){
                    System.out.println(ke.name + " " + ke.grade / ke.sum);
                }
            }
        }
        for(int i=0;i<group.aClass.length;i++) {
            if (group.aClass[i] == null) {
                break;
            }
            if (group.aClass[i].sum == 0) {
                System.out.println(group.aClass[i].id + " has no grades yet");
            } else {
                System.out.println(group.aClass[i].id + " " + group.aClass[i].grade / group.aClass[i].sum);
            }
        }
    }
}

class Ke implements Comparable<Ke> {
    String name;//课程名称
    int xiu;//选修类型
    int kind;//考核类型
    int sum=0,grade=0,grade1=0,grade2=0,arr=0;
    float[]a = new float[100];
    public Ke(String name,int xiu,int kind,float[] b){
        this.name = name;
        this.xiu = xiu;
        this.kind = kind;
        for(int i=0;i<b.length;i++){
            a[i]=b[i];
            if(b[i]!=0){
                arr++;
            }
        }
    }
    public void add(int g1,int g2,boolean it){
        sum++;
        if(it) {
            float x=a[0]*g1+a[1]*g2;
            grade1 += g1;
            grade2 += g2;
            grade += (int) (x);

        }
        else {
            grade += g2;
        }
    }
    public String getName(){
        return name;
    }

    @Override
    public int compareTo(Ke o) {
        Collator collator = Collator.getInstance(Locale.CHINA);
        return collator.compare(this.name, o.getName());
    }
}


class Group {
    Class aClass[] = new Class[100];
    public void add(String id){
        Class aClass1 = new Class(id);
        for(int i=0;i<aClass.length;i++) {
            if(aClass[i]==null){
                aClass[i]=aClass1;break;
            }
            else if(aClass[i].id.equals(id)){
                break;
            }
        }
    }
    public void total(Stus st) {
        for (int i = 0; i < aClass.length; i++) {
            if(aClass[i]==null){
                break;
            }
            for (int j = 0; j < st.stus.length; j++) {
                if (st.stus[j] == null) {
                    break;
                }
                String s = st.stus[j].id.substring(0, 6);
                if(aClass[i].id.equals(s) && st.stus[j].sum!=0){
                    aClass[i].add(st.stus[j].grade/st.stus[j].sum);
                }
            }
        }
    }
    public void xiugai(){
        int N=0;
        for(int i=0;i<aClass.length;i++){
            if(aClass[i]==null){
                break;
            }
            N++;
        }
        for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (aClass[j].id.compareTo(aClass[j+1].id)>0) { //比较相邻的两个元素
                    String id;int grade,sum;
                    id = aClass[j].id;aClass[j].id=aClass[j+1].id;aClass[j+1].id=id;
                    grade = aClass[j].grade;aClass[j].grade=aClass[j+1].grade;aClass[j+1].grade=grade;
                    sum = aClass[j].sum;aClass[j].sum=aClass[j+1].sum;aClass[j+1].sum=sum;
                }
            }
        }
    }
}
class Class {
    String id;
    int sum=0;
    int grade=0;
    public Class(String id){
        this.id=id;
    }
    public void add(int p){
        grade+=p;
        sum++;
    }
}
class Schedule {
    Locale locale = new Locale("zh", "CN");
    Collator collator = Collator.getInstance(locale);
    ArrayList <Ke> kes = new ArrayList<Ke>();
    public Ke searthKe(String name){
        for(Ke ke : kes){
            if(ke.name.equals(name)) {
                return ke;
            }
        }
        return null;
    }
    public Ke addKe(String name,int xiu,int kind,float[] b){
        Ke ke = new Ke(name,xiu,kind,b);
        for(Ke ke1 : kes){
            if(ke1.name.equals(name)) {
                return null;
            }
        }
        kes.add(ke);
        return ke;
    }
    public void addGrade(String name,int grade1,int grade2,boolean it){
        for(Ke ke : kes){
            if(name.equals(ke.name)) {
                ke.add(grade1,grade2,it);break;
            }
        }
    }

    public void paixu(){
        Collections.sort(kes);
    }
}



class Student {//学生类
    String id;
    String name;
    int grade=0;
    int sum=0;
    ArrayList<String>menu = new ArrayList<>();
    public Student(String id ,String name){
        this.id=id;
        this.name=name;
    }
    public void add(int p,String ke,boolean it){
        grade+=p;
        if(it) {
            sum++;menu.add(ke);
        }
    }
}
class Stus {//记录学生的数组
    Student stus[] = new Student[100];
    public boolean addstudent(String id,String name,int grade,boolean it,String ke){
        for(int i=0;i<stus.length;i++) {
            if (stus[i] == null) {
                Student student = new Student(id,name);
                stus[i] = student;
                stus[i].add(grade,ke,it);
                return true;
            }
            else if (id.equals(stus[i].id)) {
                boolean lazy=true;
                for(String ke1 : stus[i].menu){
                    if(ke.equals(ke1)) {
                        lazy=false;break;
                    }
                }
                if(lazy) {
                    stus[i].add(grade, ke, it);
                    return true;
                }
                return false;
            }
        }
        return false;
    }


    public void paixu(){
        int N=0;
        for(int i=0;i<stus.length;i++){
            if(stus[i]==null){
                break;
            }
            N++;
        }
        for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
            for (int j = 0; j<N - 1 - i; j++)
            {
                if (stus[j].id.compareTo(stus[j+1].id)>0) { //比较相邻的两个元素
                    String id,name;int grade,sum;
                    id = stus[j].id;stus[j].id=stus[j+1].id;stus[j+1].id=id;
                    name = stus[j].name;stus[j].name=stus[j+1].name;stus[j+1].name=name;
                    grade = stus[j].grade;stus[j].grade=stus[j+1].grade;stus[j+1].grade=grade;
                    sum = stus[j].sum;stus[j].sum=stus[j+1].sum;stus[j+1].sum=sum;
                }
            }
        }
    }
}
class Tranform {
    public int getsize(String[] split) {
        //System.out.println(split[0]);
        String id = split[0];
        String[] arr = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
        for (int i = 0; i < 9; i++) {
            if (id.substring(0, 1).equals(arr[i])) {
                return 2;
            }
        }
        return 1;
    }
}

 

下面是参考类图：

 

　　1.题目变化：

　　课程成绩统计程序-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"

 

　　2.分析：

　　这一次的变化相较于上次要更难，首先是计算成绩时采用了更加严格的赋权制，所有考试课和实验课课程都可能有4到9个单个成绩项，对应的有4到9个权值，

　　计算时按照权值来得到总成绩，字符串的判断上几乎需要全改，比较麻烦，容易出错

　　

　　3.问题&建议

　　有几个测试点一直过不去，我尝试找了很久，都没有找到明显的错误，这里想提个建议，能不能把三次作业的测试点都放出来，好让我们去找一下自己代码的不足，

　　这样也能提升自己的水平，单纯只是放出补题感觉用处不大。。。。。。。

 　　

　　2.7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

　　题目描述如下：

　　定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:

 

　　public Integer push(Integer item);
　　//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

　　public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
　　public Integer peek();  //获得栈顶元素，如果为空，则返回null.
　　public boolean empty(); //如果为空返回true
　　public int size();      //返回栈中元素个数

 

　　定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。

　　main方法说明

1. 输入n，建立可包含n个元素的ArrayIntegerStack对象
2. 输入m个值，均入栈。每次入栈均打印入栈返回结果。
3. 输出栈顶元素，输出是否为空，输出size
4. 使用Arrays.toString()输出内部数组中的值。
5. 输入x，然后出栈x次，每次出栈均打印。
6. 输出栈顶元素，输出是否为空，输出size
7. 使用Arrays.toString()输出内部数组中的值。

　　思考

　　如果IntegerStack接口的实现类内部使用ArrayList来存储元素，怎么实现？测试代码需要进行什么修改？

　　代码如下：

　　

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 读入n
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        // 创建ArrayIntegerStack对象
        ArrayIntegerStack stack = new ArrayIntegerStack(n);
        ArrayIntegerStack stack1 = new ArrayIntegerStack(n);
        
        // 依次将m个值压入栈中，并打印结果
        for (int i = 0; i < m; i++) {
            int val = sc.nextInt();
            Integer res = stack.push(val);
            Integer res1 = stack1.push(val);
            System.out.println(res != null ? res : "null");
        }

        // 输出栈顶元素、是否为空和大小
        //System.out.println(stack.peek());
        System.out.println(stack.peek()+","+stack.empty() + "," + stack.size());

        // 输出内部数组中的值
        System.out.println(Arrays.toString(stack.stack));

        // 输入x并出栈x次，每次出栈均打印
        int x = sc.nextInt();
        while (x > 0) {
            Integer res = stack.pop();
            System.out.println(res != null ? res : "null");
            x--;
        }

        // 输出栈顶元素、是否为空和大小
       //System.out.println(stack.peek());
        System.out.println(stack.peek()+","+stack.empty() + "," + stack.size());

        // 输出内部数组中的值
        System.out.println(Arrays.toString(stack1.stack));
    }
}

// 实现IntegerStack接口
class ArrayIntegerStack implements IntegerStack {
    Integer[] stack;  // 内部数组
    int size;         // 栈的大小

    public ArrayIntegerStack(int capacity) {
        stack = new Integer[capacity];
        size = 0;
    }

    @Override
    public Integer push(Integer item) {
        if (size == stack.length) {  // 栈已满
            return null;
        }
        stack[size++] = item;  // 将新元素加入栈顶
        return item;
    }

    @Override
    public Integer pop() {
        if (size == 0) {  // 栈已空
            return null;
        }
        Integer top = peek();  // 取出栈顶元素
        stack[--size] = null;  // 将栈顶元素出栈，并将其置为null
        return top;
    }

    @Override
    public Integer peek() {
        if (size == 0) {  // 栈已空
            return null;
        }
        return stack[size - 1];  // 返回栈顶元素
    }

    @Override
    public boolean empty() {
        return size == 0;  // 栈是否为空
    }

    @Override
    public int size() {
        return size;  // 栈的大小
    }
}

// 定义整数栈接口
interface IntegerStack {
    Integer push(Integer item);  // 元素入栈
    Integer pop();               // 元素出栈
    Integer peek();              // 返回栈顶元素
    boolean empty();             // 判断是否为空
    int size();                  // 返回栈的大小
}

 

　　分析：

　　主要问题在于要掌握相关接口的使用方法，写出栈的类之后还要注意输出的描述，第一次和第二次输出的都应该是初始的内部数组，而不是出栈之后的数组。

（3）采坑心得：

　　主要还是对课程pta作业8分析一下：

　　1.课程成绩统计系统没有满分，下面附一张运行结果的图：

 

　　这个测试用例是没有任何问题的，但是其他的测试点我不知道为什么会出错。。。。。。。

 

　　2.7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

　　下面是正确的代码的运行结果：

 

　　如果后面的输出没有改正，那么会是下面的结果：

 

　　

　　分析：在课程成绩统计系统中if语句太多太杂，非常绕，我自己写完也要花点时间爱知道自己写的是什么，主要是没有注释，所以应该在这种代码段里添加注释，方便修改和阅读

 　　

（4）主要困难以及改进建议：

　　1.主要困难：

　　其实总的来说三次题目都不算很难，主要还是自己要沉下心来去做，把框架搭好，不要总是依赖老师给好的框架，这样自己的能力才会提高，

　　最后就是要细心吧，因为测试点很多，要保证一个系统的完善就要非常细致。

　　2.改进建议：

　　1.主函数写得太臃肿了，真的需要思考一下，怎么简化它。

　　2.一个完善的系统应该可以加入保护信息或者反馈错误的功能，可以自己尝试实现。

　　3.可以和同学交流一下，取长补短，以此完善自己的代码。

（5）总结：

　　这三次的题目，使我对Java面向对象的知识的掌握更进一步，同时在这段时间的学习中也培养了自己设计和打框架的能力，

　　经过这三次的锻炼，我觉得自己对面向对象程序设计已经不再像以前那样排斥，甚至可以说比较接受了，而且我自己的能力也在这个过程中

　　有了质的飞跃，我想这正是学习java课程给我带来的。

附：感谢老师老师的严格要求才使我能不放松不懈怠，最后在写题目中提升自己的能力。