昌航第三次博客作业

7-1 容器-HashMap-检索

分数 10

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

使用HashMap存储学生信息，并实现根据学号的检索功能

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

end之后输入某个学号，执行程序输出该生的详细信息

输出格式:

输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

如果没有查询到，则输出："The student "+查询的学号+" does not exist"

输入样例1:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20201116

输出样例1:

在这里给出相应的输出。例如：

20201116 李四 78

 

输入样例2:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20202316

输出样例2:

在这里给出相应的输出。例如：

The student 20202316 does not exist

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashMap<String, String> map = new HashMap<>();
        
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }
            String[] info = input.split(" ");
            map.put(info[0], info[1] + " " + info[2]);
        }
        
        String query = scanner.nextLine();
        if (map.containsKey(query)) {
            System.out.println(query + " " + map.get(query));
        } else {
            System.out.println("The student " + query + " does not exist");
        }
    }
}

7-2 容器-HashMap-排序

分数 10

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

要求：使用HashMap存储学生信息。

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

输出格式:

按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩

输入样例:

在这里给出一组输入。例如：

20201124 张少军 83
20201136 李四 78
20201118 郑觉先 80
end

输出样例:

在这里给出相应的输出。例如：

20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80

 

 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Map<String, String> map = new HashMap<>();
        while (sc.hasNextLine()) {
            String input = sc.nextLine();
            if (input.equals("end")) {
                break;
            }
            String[] inputs = input.split(" ");
            map.put(inputs[0], inputs[1] + " " + inputs[2]);
        }
        List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, (o1, o2) -> Integer.parseInt(o2.getKey()) - Integer.parseInt(o1.getKey()));
        for (Map.Entry<String, String> entry : list) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
}

7-3 课程成绩统计程序-2

分数 60

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

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

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

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

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

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

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

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

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

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

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

考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

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

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

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

以上信息的相关约束：

1）平时成绩和期末成绩的权重默认为0.3、0.7

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

3）学号由8位数字组成

4）姓名不超过10个字符

5）课程名称不超过10个字符

6）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

考试/考察课程成绩格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

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

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

信息约束：

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

参考类图（与第一次相同，其余内容自行补充）：

 

输入样例1:

在这里给出一组输入。例如：

java 实验 实验
20201103 张三 java 4 70 80 90
end

输出样例1:

在这里给出相应的输出。例如：

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
        messageGetAndPrint.print = new Print();
        for(;;){
            String message = in.readLine();
            if(message.equals("end")) {
                messageGetAndPrint.print.personPrint(messageGetAndPrint.students , messageGetAndPrint.courseSelections);
                messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses , messageGetAndPrint.courseSelections);
                messageGetAndPrint.print.classPrint(messageGetAndPrint.classes , messageGetAndPrint.courseSelections);
                break;
            }
            messageGetAndPrint.getMessage(message);
        }
    }
}
class Class {
    private String classNum;
    HashMap<String , Student> students;
    Class(String classNum) {
        setClassNum(classNum);
    }
    public void setClassNum(String classNum) {
           this.classNum = classNum;
    }
    public String getClassNum() {
        return classNum;
    }
    public void addStudent(Student student) {
        students.put(student.getStudentNum() , student);
    }
    public void deleteStudent(String studentNum) {
        students.remove(studentNum);
    }
}
class Student {
    private String name;
    private String studentNum;
    Student(String name , String studentNum) {
        setName(name);
        setStudentNum(studentNum);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getStudentNum() {
        return studentNum;
    }
    public void setStudentNum(String studentNum) {
        this.studentNum = studentNum;
    }
}
class Course {
    private String className;
    private int classQuality;
    private int assessmentMethodology;
    Course(String className , int classQuality , int assessmentMethodology) {
        setClassName(className);
        setClassQuality(classQuality);
        setAssessmentMethodology(assessmentMethodology);
    }
    public String getClassName() {
return className;
    }
    public void setClassName(String className) {
this.className = className;
    }
    public int getClassQuality() {
        return classQuality;
    }
    public void setClassQuality(int classQuality) {
        this.classQuality = classQuality;
    }
    public int getAssessmentMethodology() {
             return assessmentMethodology;
    }
    public void setAssessmentMethodology(int assessmentMethodology) {
        this.assessmentMethodology = assessmentMethodology;
    }
}
class CourseSelection {
     Student student;
     Course course;
     Grade grade;
}
abstract class Grade {
    int allGrade;
    abstract void getAllGrade();
}
class GradeA extends Grade {
    private int finalGrade;
    private int usualGrade;
    GradeA(int finalGrade , int usualGrade) {
        setFinalGrade(finalGrade);
        setUsualGrade(usualGrade);
    }
    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }
    public int getFinalGrade() {
        return finalGrade;
    }
    public void setUsualGrade(int usualGrade) {
        this.usualGrade = usualGrade;
    }
    public int getUsualGrade() {
return usualGrade;
    }
    @Override
    void getAllGrade() {
        allGrade = (int) (finalGrade*0.7+usualGrade*0.3);
    }
}
class GradeB extends Grade {
    private int finalGrade;
    GradeB(int finalGrade) {
        setFinalGrade(finalGrade);
    }
    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }
    public int getFinalGrade() {
        return finalGrade;
    }
    @Override
    void getAllGrade() {
        allGrade = finalGrade;
    }
}
class GradeC extends Grade {
    ArrayList<Integer> usualGrades;
    GradeC(ArrayList<Integer> usualGrades) {
        this.usualGrades = usualGrades;
    }
    @Override
    void getAllGrade() {
      
        allGrade = 0;
        for(int x:usualGrades){
            allGrade+=x;
        }
        allGrade = allGrade/usualGrades.size();
    }
}
class Print {
    public void personPrint(HashMap<String , Student> students , ArrayList<CourseSelection> courseSelections) {
        Set<String> set = students.keySet();
        Object[] arr=set.toArray();
        Arrays.sort(arr);
        for(Object key:arr) {
            int x = 0 , y = -1;
            for (CourseSelection courseSelection : courseSelections) {
                if (students.get(key).getStudentNum().equals(courseSelection.student.getStudentNum())) {
                    if(y == -1)
                        y = 0;
                    courseSelection.grade.getAllGrade();
                    x += courseSelection.grade.allGrade;
                    y++;
                }
            }
            if(y == -1) {
                System.out.println(students.get(key).getStudentNum()+" "+students.get(key).getName()+" did not take any exams");
                continue;
            }
            x = x / y;
            System.out.println(students.get(key).getStudentNum()+" "+students.get(key).getName()+" "+x);

        }
    }
    public void coursePrint(HashMap<String , Course> courses , ArrayList<CourseSelection> courseSelections) {
               
List<String> list = courses.keySet().stream().collect(Collectors.toList());
        Collections.sort(list , new SoftName());
        for(String key:list) {
            int x = 0 , y = -1 , f = 0 , u = 0 , uy = -1 , s = -1;
            for (CourseSelection courseSelection : courseSelections) {
                if (courses.get(key).getClassName().equals(courseSelection.course.getClassName())) {
                    if(y == -1)
                        y = 0;
                    if(courses.get(key).getAssessmentMethodology() == 1 && uy == -1)
                        uy = 0;
                    if(courses.get(key).getAssessmentMethodology() == 3 && s == -1)
                        s = 0;
                    courseSelection.grade.getAllGrade();
                    x += courseSelection.grade.allGrade;
                    if(courseSelection.grade instanceof GradeA) {
                        f += ((GradeA) courseSelection.grade).getFinalGrade();
                        u += ((GradeA) courseSelection.grade).getUsualGrade();
                        uy++;
                    }
                    if(courseSelection.grade instanceof GradeB) {
                        f += ((GradeB) courseSelection.grade).getFinalGrade();
                    }
                    y++;
                }
            }
            if(y == -1) {
                System.out.println(courses.get(key).getClassName()+" has no grades yet");
                continue;
            }
            x = x/y;
            f = f/y;
            if(s == 0) {
                System.out.println(courses.get(key).getClassName()+" "+x);
                continue;
            }
            if(uy == -1) {
                System.out.println(courses.get(key).getClassName()+" "+f+" "+x);
            }
            if(uy != -1) {
                u = u/uy;
                System.out.println(courses.get(key).getClassName()+" "+u+" "+f+" "+x);
            }
        }
    }
    public void classPrint(HashMap<String , Class> classes , ArrayList<CourseSelection> courseSelections) {
          
        Set<String> set = classes.keySet();
        Object[] arr=set.toArray();
        Arrays.sort(arr);
        for(Object key:arr) {
            int x = 0 , y = -1;
            for(CourseSelection courseSelection : courseSelections) {
                if(classes.get(key).students.containsKey(courseSelection.student.getStudentNum())) {
                    if(y == -1) {
                        y = 0;
                    }
                    courseSelection.grade.getAllGrade();
                    x += courseSelection.grade.allGrade;
                    y++;
                }
            }
            if(y == -1) {
                System.out.println(classes.get(key).getClassNum()+" has no grades yet");
                continue;
            }
            x = x/y;
            System.out.println(classes.get(key).getClassNum()+" "+x);
        }
    }
    public void wrongFormat() {
        System.out.println("wrong format");
    }
    public void courseExist(String name) {
        System.out.println(name+" does not exist");
    }
    public void courseMatch(String studentNum , String studentName) {
        System.out.println(studentNum+" "+studentName+" : access mode mismatch");
    }
    public void courseMatch(String name) {
        System.out.println(name+" : course type & access mode mismatch");
    }
    static class SoftName implements Comparator<String>{
        public int compare(String name1 , String name2) {
            Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
            return compare.compare(name1 , name2);
        }
    }
}
class MessageGetAndPrint {
    Print print;
    HashMap<String , Class> classes = new HashMap<>();
    HashMap<String , Student> students = new HashMap<>();
    HashMap<String , Course> courses = new HashMap<>();
    ArrayList<CourseSelection> courseSelections = new ArrayList<>();
    public void getMessage(String getInput) {
             

        String[] message = getInput.split(" ");
        if(getInput.matches("^(\\S{1,10})( )(必修)$")) {
            int i = 1, j = 1;
            if(courses.containsKey(message[0])) {
                return;
            }
            Course course = new Course(message[0], i, j);
            courses.put(message[0], course);
            return;
        }
        if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$")) {
            int i = 0, j = 0;
            if(message[1].equals("必修")) {
                i = 1;
            }
            if(message[1].equals("选修")) {
                i = 2;
            }
            if(message[1].equals("实验")) {
                i = 3;
            }
            if(message[2].equals("考试")) {
                j = 1;
            }
            if(message[2].equals("考察")) {
                j = 2;
            }
            if(message[2].equals("实验")) {
                j = 3;
            }
            if(i == 1 && j != 1) {
                print.courseMatch(message[0]);
                return;
            }
            if(i == 3 && j != 3) {
                print.courseMatch(message[0]);
                return;
            }
            if(i != 3 && j == 3) {
                print.courseMatch(message[0]);
                return;
            }
            if(courses.containsKey(message[0])) {
                return;
            }
            Course course = new Course(message[0], i, j);
            courses.put(message[0], course);
            return;
        }
if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$")) {
            for(CourseSelection courseSelection:courseSelections) {
                if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
                    return;
                }
            }
            Student student = new Student(message[1], message[0]);
            students.put(message[0] , student);
            String classNum = message[0].substring(0 , 6);
            if(!classes.containsKey(classNum)) {
                Class aClass = new Class(classNum);
                classes.put(classNum , aClass);
                classes.get(classNum).students = new HashMap<>();
            }
            classes.get(classNum).students.put(message[0], student);
            if(!courses.containsKey(message[2])) {
                print.courseExist(message[2]);
                return;
            }
            if(courses.get(message[2]).getAssessmentMethodology() != 1) {
                print.courseMatch(message[0] , message[1]);
                return;
            }
            CourseSelection courseSelection = new CourseSelection();
            courseSelection.student = student;
            courseSelection.course = courses.get(message[2]);
            int finalGrade = Integer.parseInt(message[4]);
            int usualGrade = Integer.parseInt(message[3]);
            courseSelection.grade = new GradeA(finalGrade , usualGrade);
            courseSelections.add(courseSelection);
            return;
        }
    if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|10{2})$")) {
            for(CourseSelection courseSelection:courseSelections) {
                if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
                    return;
                }
            }
            Student student = new Student(message[1], message[0]);
            students.put(message[0] , student);
            String classNum = message[0].substring(0 , 6);
            if(!classes.containsKey(classNum)) {
                Class aClass = new Class(classNum);
                classes.put(classNum , aClass);
                classes.get(classNum).students = new HashMap<>();
            }
            classes.get(classNum).addStudent(student);
            if(!courses.containsKey(message[2])) {
                print.courseExist(message[2]);
                return;
            }
            if(courses.get(message[2]).getAssessmentMethodology() != 2) {
                print.courseMatch(message[0] , message[1]);
                return;
            }
            CourseSelection courseSelection = new CourseSelection();
            courseSelection.student = student;
            courseSelection.course = courses.get(message[2]);
            int finalGrade = Integer.parseInt(message[3]);
            courseSelection.grade = new GradeB(finalGrade);
            courseSelections.add(courseSelection);
            return;
        }
if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((([0-9]|[1-9][0-9]|100)( ))+)([0-9]|[1-9][0-9]|100)$")) {
            for(CourseSelection courseSelection:courseSelections) {
                if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
                    return;
                }
            }
            Student student = new Student(message[1], message[0]);
            students.put(message[0] , student);
            String classNum = message[0].substring(0 , 6);
            if(!classes.containsKey(classNum)) {
                Class aClass = new Class(classNum);
                classes.put(classNum , aClass);
                classes.get(classNum).students = new HashMap<>();
            }
            classes.get(classNum).addStudent(student);
            if(!courses.containsKey(message[2])) {
                print.courseExist(message[2]);
                return;
            }
            if(courses.get(message[2]).getAssessmentMethodology() != 3) {
                print.courseMatch(message[0] , message[1]);
                return;
            }
            int usualNum = Integer.parseInt(message[3]);
            if(message.length-4 != usualNum) {
                print.courseMatch(message[0] , message[1]);
                return;
            }
            CourseSelection courseSelection = new CourseSelection();
            courseSelection.student = student;
            courseSelection.course = courses.get(message[2]);
            ArrayList<Integer> usualGrades = new ArrayList<>();
            for(int i = 1;i <= usualNum;i++) {
                usualGrades.add(Integer.parseInt(message[3+i]));
            }
            courseSelection.grade = new GradeC(usualGrades);
            courseSelections.add(courseSelection);
            return;
        }
        print.wrongFormat();
         

    }
}

 

 

7-4 动物发声模拟器（多态）

分数 20

全屏浏览题目

切换布局

作者 刘凤良

单位 天津仁爱学院

设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码。

 

//动物发生模拟器.  请在下面的【】处添加代码。
public class AnimalShoutTest2 {
    public static void main(String[] args) {        
         Cat cat = new Cat();
         Dog dog = new Dog();        
        Goat goat = new Goat();
         speak(cat);
         speak(dog);
         speak(goat);
    }
    //定义静态方法speak()
    【】

}

//定义抽象类Animal
【】class Animal{
    【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
    【】    
    【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
    【】
    【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
    【】
    【】
}

输入样例:

输出样例:

猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

 

 

//动物发声模拟器. 请在下面的【】处添加代码。
public class Main {
    public static void main(String[] args) {        
        Cat cat = new Cat();
        Dog dog = new Dog();        
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }
    //定义静态方法speak()
    public static void speak(Animal animal){
        System.out.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
    }

}

//定义抽象类Animal
abstract class Animal{
    public abstract String getAnimalClass();
    public abstract String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
    @Override
    public String getAnimalClass(){
        return "猫";
    }
    
    @Override
    public String shout(){
        return "喵喵";
    }
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
    @Override
    public String getAnimalClass(){
        return "狗";
    }
    
    @Override
    public String shout(){
        return "汪汪";
    }
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
    @Override
    public String getAnimalClass(){
        return "山羊";
    }
    
    @Override
    public String shout(){
        return "咩咩";
    }
}

7-1 立体图形问题

分数 10

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。

类结构如下图所示（参考）：

试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：

 

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner input = new Scanner(System.in);
    double side = input.nextDouble();
        
    display(new Cube(side));
    display(new RegularPyramid(side));
}

其中，display(Solid solid)方法为定义在Main类中的静态方法，作用为体现程序的多态性。

注：正三棱锥的体积计算公式为底面积*高/3。

输入格式:

输入一个实型数，分别作为正方体的边长和正三棱锥的边长。

输出格式:

分别输出正方体的表面积、体积以及正棱锥的表面积和体积。保留两位小数，建议使用String.format(“%.2f”,value)

进行小数位数控制。

输入样例:

在这里给出一组输入。例如：

2.5

输出样例:

在这里给出相应的输出。例如：

37.50
15.63
10.83
1.84

 

 

import java.util.Scanner;

// 定义一个抽象类Solid
abstract class Solid {
    // 定义抽象方法，用于计算表面积
    public abstract double surfaceArea();

    // 定义抽象方法，用于计算体积
    public abstract double volume();
}

// 定义正方体类Cube，继承抽象类Solid
class Cube extends Solid {
    private double side;

    // 构造方法，初始化正方体的边长
    public Cube(double side) {
        this.side = side;
    }

    // 实现抽象方法，计算正方体的表面积
    public double surfaceArea() {
        return 6 * side * side;
    }

    // 实现抽象方法，计算正方体的体积
    public double volume() {
        return side * side * side;
    }
}

// 定义正三棱锥类RegularPyramid，继承抽象类Solid
class RegularPyramid extends Solid {
    private double side;

    // 构造方法，初始化正三棱锥的边长
    public RegularPyramid(double side) {
        this.side = side;
    }
    //sin60
    // 实现抽象方法，计算正三棱锥的表面积
    public double surfaceArea() {
        double slantHeight = Math.sqrt(3) * side * side;
        return slantHeight;
    }

    // 实现抽象方法，计算正三棱锥的体积
    public double volume() {
        return Math.sqrt(3) * Math.sqrt(6) / 2 * side * side * side / 18;
    }
}

public class Main {
    // 定义静态方法display，用于打印图形的表面积和体积
    public static void display(Solid solid) {
        System.out.println(String.format("%.2f", solid.surfaceArea()));
        System.out.println(String.format("%.2f", solid.volume()));
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        double side = input.nextDouble();

        display(new Cube(side));
        display(new RegularPyramid(side));
    }
}

7-2 魔方问题

分数 20

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

问题描述：本问题中的魔方有两种，一种是正方体魔方，一种是正三棱锥魔方，其中，正方体或正三棱锥魔方是由单元正方体或正三棱锥组成，单元正方体或正三棱锥的个数由阶数（即层数）决定，即魔方边长=阶数*单元边长。魔方如下图所示：

利用“立体图形”问题源码，实现如下功能：

魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：

主方法部分可参考如下源码（可拷贝直接使用）：

 

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();        
        
        RubikCube cube1 = new SquareCube(color, layer,new Cube(side)); 
                
        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();
        
        RubikCube cube2 = new RegularPyramidCube(color, layer,new RegularPyramid(side));
        display(cube1);
        display(cube2);
    }
}

其中，display(RubikCube cube)方法为Main类中定义的静态方法，用户输出魔方的信息，用于体现多态性。

输入格式:

第一部分：正方体魔方颜色、阶数、单元正方体边长，以空格或回车分隔；

第二部分：正三棱锥魔方颜色、阶数、单元正三棱锥边长，以空格或回车分隔。

输出格式:

正方体魔方颜色

正方体魔方表面积

正方体魔方体积

正三棱锥魔方颜色

正三棱锥魔方表面积
正三棱锥魔方体积

注：小数点保留两位

输入样例:

在这里给出一组输入。例如：

red 3 4.5
black 4 2.1

输出样例:

在这里给出相应的输出。例如：

red
1093.50
2460.38
black
122.21
69.85

 

 

import java.util.Scanner;

// 定义一个抽象类Solid
abstract class Solid {
    // 定义抽象方法，用于计算表面积
    public abstract double surfaceArea();

    // 定义抽象方法，用于计算体积
    public abstract double volume();
}

// 定义正方体类Cube，继承抽象类Solid
class Cube extends Solid {
    private double side;

    // 构造方法，初始化正方体的边长
    public Cube(double side) {
        this.side = side;
    }

    // 实现抽象方法，计算正方体的表面积
    public double surfaceArea() {
        return 6 * side * side;
    }

    // 实现抽象方法，计算正方体的体积
    public double volume() {
        return side * side * side;
    }
}

// 定义正三棱锥类RegularPyramid，继承抽象类Solid
class RegularPyramid extends Solid {
    private double side;

    // 构造方法，初始化正三棱锥的边长
    public RegularPyramid(double side) {
        this.side = side;
    }

    // 实现抽象方法，计算正三棱锥的表面积
    public double surfaceArea() {
        double slantHeight = Math.sqrt(3) * side * side;
        return slantHeight;
    }

    // 实现抽象方法，计算正三棱锥的体积
    public double volume() {
        return Math.sqrt(3) * Math.sqrt(6) / 2 * side * side * side / 18;
    }
}

// 定义魔方类RubikCube，继承抽象类Solid
abstract class RubikCube extends Solid {
    protected String color;
    protected int layer;

    public RubikCube(String color, int layer) {
        this.color = color;
        this.layer = layer;
    }

    public String getColor() {
        return color;
    }

}

// 定义正方体魔方类SquareCube，继承魔方类RubikCube
class SquareCube extends RubikCube {
    private Cube cube;

    // 构造方法，初始化正方体魔方的颜色、阶数和单元正方体
    public SquareCube(String color, int layer, Cube cube) {
        super(color, layer);
        this.cube = cube;
    }

    // 实现抽象方法，计算正方体魔方的表面积
    public double surfaceArea() {
        return cube.surfaceArea() * layer * layer;
    }

    // 实现抽象方法，计算正方体魔方的体积
    public double volume() {
        return cube.volume() * layer * layer * layer;
    }
}

// 定义正三棱锥魔方类RegularPyramidCube，继承魔方类RubikCube
class RegularPyramidCube extends RubikCube {
    private RegularPyramid pyramid;

    // 构造方法，初始化正三棱锥魔方的颜色、阶数和单元正三棱锥
    public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
        super(color, layer);
        this.pyramid = pyramid;
    }

    // 实现抽象方法，计算正三棱锥魔方的表面积
    public double surfaceArea() {
        return pyramid.surfaceArea() * layer * layer;
    }

    // 实现抽象方法，计算正三棱锥魔方的体积
    public double volume() {
        return pyramid.volume() * layer * layer * layer;
    }
}

public class Main {
    // 定义静态方法display，用于打印魔方的信息
    public static void display(RubikCube cube) {
        System.out.println(cube.getColor());
        System.out.println(String.format("%.2f", cube.surfaceArea()));
        System.out.println(String.format("%.2f", cube.volume()));
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        String color = input.next();
        int layer = input.nextInt();
        double side = input.nextDouble();

        RubikCube cube1 = new SquareCube(color, layer, new Cube(side));

        color = input.next();
        layer = input.nextInt();
        side = input.nextDouble();

        RubikCube cube2 = new RegularPyramidCube(color, layer, new RegularPyramid(side));
        display(cube1);
        display(cube2);
    }
}

7-3 魔方排序问题

分数 20

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

在魔方问题的基础上，重构类设计，实现列表内魔方的排序功能（按照魔方的体积进行排序）。

提示：题目中RubikCube类要实现Comparable接口。

其中，Main类源码如下（可直接拷贝使用）：

 

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        
        String color;
        int layer;
        double side;
        RubikCube cube;
        
        ArrayList<RubikCube> list = new ArrayList<>();
        
        int choice = input.nextInt();
        
        while(choice != 0) {
            switch(choice) {
            case 1://SquareCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new SquareCube(color, layer,new Cube(side)); 
                list.add(cube);
                break;
            case 2://RegularPyramidCube
                color = input.next();
                layer = input.nextInt();
                side = input.nextDouble();
                cube = new RegularPyramidCube(color, layer,new RegularPyramid(side)); 
                list.add(cube);
                break;
            }
            choice = input.nextInt();
        }
        
        list.sort(Comparator.naturalOrder());//正向排序
        
        for(int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getColor() + " " + 
        String.format("%.2f", list.get(i).getArea()) + " " + 
        String.format("%.2f", list.get(i).getVolume()) );
            System.out.println("");
        }            
    }    
}

输入格式:

输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）

魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长

..循环..

输出格式:

按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。

输入样例:

在这里给出一组输入。例如：

1 blue 3 4.5
2 red 4 2.1
1 yellow 5 2.3
2 black 4 9.42
1 white 4 5.4423
0

输出样例:

在这里给出相应的输出。例如：

red 122.21 69.85
yellow 793.50 1520.88
blue 1093.50 2460.38
black 2459.14 6304.73
white 2843.39 10316.38

 

 

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

// 魔方类
abstract class RubikCube implements Comparable<RubikCube> {
    private String color;

    public RubikCube(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    // 计算面积（抽象方法）
    public abstract double getArea();

    // 计算体积（抽象方法）
    public abstract double getVolume();

    // 实现Comparable接口，按体积升序排序
    @Override
    public int compareTo(RubikCube other) {
        BigDecimal volume1 = new BigDecimal(Double.toString(this.getVolume()));
        BigDecimal volume2 = new BigDecimal(Double.toString(other.getVolume()));
        return volume1.compareTo(volume2);
    }
}

// 正方体魔方类
class SquareCube extends RubikCube {
    private Cube cube;

    public SquareCube(String color, int layer, Cube cube) {
        super(color);
        this.cube = cube;
    }

    @Override
    public double getArea() {
        return cube.getArea();
    }

    @Override
    public double getVolume() {
        return cube.getVolume();
    }
}

// 正三棱锥魔方类
class RegularPyramidCube extends RubikCube {
    private RegularPyramid pyramid;

    public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
        super(color);
        this.pyramid = pyramid;
    }

    @Override
    public double getArea() {
        return pyramid.getArea();
    }

    @Override
    public double getVolume() {
        return pyramid.getVolume();
    }
}

// 正方体类
class Cube {
    private double side;

    public Cube(double side) {
        this.side = side;
    }

    public double getArea() {
        BigDecimal area = new BigDecimal(Double.toString(6 * side * side));
        return area.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    public double getVolume() {
        BigDecimal volume = new BigDecimal(Double.toString(side * side * side));
        return volume.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

// 正三棱锥类
class RegularPyramid {
    private double side;

    public RegularPyramid(double side) {
        this.side = side;
    }

    public double getArea() {
        BigDecimal area = new BigDecimal(Double.toString(Math.sqrt(3) * side * side));
        return area.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    public double getVolume() {
        BigDecimal volume = new BigDecimal(Double.toString(Math.sqrt(18) * side * side * side / 36));
        return volume.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        String color;
        double side;
        RubikCube cube;

        ArrayList<RubikCube> list = new ArrayList<>();
        int layer;
        int choice = input.nextInt();

        while (choice != 0) {
            switch (choice) {
                case 1:// SquareCube
                    color = input.next();
                     layer = input.nextInt();
                    side = input.nextDouble();
                    cube = new SquareCube(color, layer, new Cube(side));
                    list.add(cube);
                    break;
                case 2:// RegularPyramidCube
                    color = input.next();
                    layer = input.nextInt();
                    side = input.nextDouble();
                    cube = new RegularPyramidCube(color, layer, new RegularPyramid(side));
                    list.add(cube);
                    break;
            }
            choice = input.nextInt();
        }

        list.sort(Comparator.naturalOrder());// 正向排序

        for (RubikCube c : list) {
            System.out.printf("%s %.2f %.2f%n", c.getColor(),  layer *layer *c.getArea(), layer *layer *layer *c.getVolume());
        }
    }
}

7-4 销售步枪问题（附加题）

分数 10

全屏浏览题目

切换布局

作者 段喜龙

单位 南昌航空大学

前亚利桑那州境内的一位步枪销售商销售密苏里州制造的步枪机（lock）、枪托（stock）和枪管（barrel）。枪机卖45美元，枪托卖30美元，枪管卖25美元。销售商每月至少要售出一支完整的步枪，且生产限额是销售商在一个月内可销售70个枪机、80个枪托和90个枪管。

根据每个月的销售情况，计算销售商的佣金（提成）算法如下：

• 不到（含）1000美元的部分为10%；

• 1000（含）~1800美元的部分为15%；

• 超过1800美元的部分为20%。

佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。

编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。

提示：可以设置一个销售订单类。参考类图如下：

输入格式:

输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。

输出格式:

分别输出销售商在该月的销售额和佣金，中间用空格分开。

输入样例1:

在这里给出一组输入。例如：

30 40 50

输出样例1:

在这里给出相应的输出。例如：

3800.00 620.00

输入样例2:
在这里给出一组输入。例如：

88 56 98

输出样例2:
在这里给出相应的输出。例如：

Wrong Format

 

 

import java.util.Scanner;

// 销售订单类
class SalesOrder {
    private int gunCount;
    private int stockCount;
    private int barrelCount;

    public SalesOrder(int gunCount, int stockCount, int barrelCount) {
        this.gunCount = gunCount;
        this.stockCount = stockCount;
        this.barrelCount = barrelCount;
    }

    public int getGunCount() {
        return gunCount;
    }

    public int getStockCount() {
        return stockCount;
    }

    public int getBarrelCount() {
        return barrelCount;
    }
}

// 步枪销售商类
class GunSeller {
    private static final double GUN_PRICE = 45.0;
    private static final double STOCK_PRICE = 30.0;
    private static final double BARREL_PRICE = 25.0;
    private static final double COMMISSION_RATE_1 = 0.1;
    private static final double COMMISSION_RATE_2 = 0.15;
    private static final double COMMISSION_RATE_3 = 0.2;
    private static final double THRESHOLD_1 = 1000.0;
    private static final double THRESHOLD_2 = 1800.0;

    private SalesOrder salesOrder;

    public GunSeller(SalesOrder salesOrder) {
        this.salesOrder = salesOrder;
    }

    public double getSalesAmount() {
        int gunCount = salesOrder.getGunCount();
        int stockCount = salesOrder.getStockCount();
        int barrelCount = salesOrder.getBarrelCount();

        double gunAmount = gunCount * GUN_PRICE;
        double stockAmount = stockCount * STOCK_PRICE;
        double barrelAmount = barrelCount * BARREL_PRICE;

        return gunAmount + stockAmount + barrelAmount;
    }

    public double getCommission() {
        double salesAmount = getSalesAmount();

        if (salesAmount <= THRESHOLD_1) {
            return salesAmount * COMMISSION_RATE_1;
        } else if (salesAmount <= THRESHOLD_2) {
            double commission1 = THRESHOLD_1 * COMMISSION_RATE_1;
            double commission2 = (salesAmount - THRESHOLD_1) * COMMISSION_RATE_2;
            return commission1 + commission2;
        } else {
            double commission1 = THRESHOLD_1 * COMMISSION_RATE_1;
            double commission2 = (THRESHOLD_2 - THRESHOLD_1) * COMMISSION_RATE_2;
            double commission3 = (salesAmount - THRESHOLD_2) * COMMISSION_RATE_3;
            return commission1 + commission2 + commission3;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int gunCount = input.nextInt();
        int stockCount = input.nextInt();
        int barrelCount = input.nextInt();
        if (gunCount > 70 || stockCount > 80 || barrelCount > 90) {
            System.out.println("Wrong Format");
        }
        else if (gunCount <= 0 || stockCount <= 0 || barrelCount <= 0) {
            System.out.println("Wrong Format");
        } else {
            SalesOrder salesOrder = new SalesOrder(gunCount, stockCount, barrelCount);
            GunSeller gunSeller = new GunSeller(salesOrder);

            double salesAmount = gunSeller.getSalesAmount();
            double commission = gunSeller.getCommission();

            System.out.printf("%.2f %.2f", salesAmount, commission);
        }
    }
}

7-1 容器-ArrayList-排序

分数 12

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

题目描述

编辑

输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

要求：使用ArrayList存储学生信息。

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩

以“end”为输入结束标志

输出格式:

按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和

成绩相同的情况，按输入的先后顺序输出。

输入样例:

在这里给出一组输入。例如：

20201124 张少军 83 75
20201136 李四 78 86
20201118 郑觉先 80 62
end

输出样例:

在这里给出相应的输出。例如：

20201136 李四 164
20201124 张少军 158
20201118 郑觉先 142

 

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

// 自定义学生类
class Student {
    String id;
    String name;
    int mathScore;
    int physicsScore;

    public Student(String id, String name, int mathScore, int physicsScore) {
        this.id = id;
        this.name = name;
        this.mathScore = mathScore;
        this.physicsScore = physicsScore;
    }

    public int getTotalScore() {
        return mathScore + physicsScore;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        // 读取输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }

            String[] info = input.split(" ");
            String id = info[0];
            String name = info[1];
            int mathScore = Integer.parseInt(info[2]);
            int physicsScore = Integer.parseInt(info[3]);

            Student student = new Student(id, name, mathScore, physicsScore);
            students.add(student);
        }

        // 按成绩之和排序
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int totalScore1 = s1.getTotalScore();
                int totalScore2 = s2.getTotalScore();
                return totalScore2 - totalScore1; // 降序排列
            }
        });

        // 输出结果
        for (Student student : students) {
            System.out.println(student.id + " " + student.name + " " + student.getTotalScore());
        }
    }
}

7-2 课程成绩统计程序-3

分数 64

全屏浏览题目

切换布局

作者 蔡轲

单位 南昌航空大学

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

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

完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。

题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。

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

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

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

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

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

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

1、输入：

包括课程、课程成绩两类信息。

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

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

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

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

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

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

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

考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

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

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

以上信息的相关约束：

1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

2）学号由8位数字组成

3）姓名不超过10个字符

4）课程名称不超过10个字符

5）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免四舍五入误差，

计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。

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

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

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

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

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

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

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

信息约束：

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

参考类图（与第一次相同，其余内容自行补充）：

输入样例1:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
end

输出样例1:

在这里给出相应的输出。例如：

java has no grades yet

输入样例2:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2
end

输出样例2:

在这里给出相应的输出。例如：

java : number of scores does not match

输入样例3:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.1
end

输出样例3:

在这里给出相应的输出。例如：

java : weight value error

输入样例4:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end

输出样例4:

在这里给出相应的输出。例如：

20201116 张三 86
java 86
202011 86

输入样例5:

在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end

输出样例5:

在这里给出相应的输出。例如：

20201116 张三 : access mode mismatch
20201116 张三 did not take any exams
java has no grades yet
202011 has no grades yet

 

 

import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Main {

    public static Scanner sc = new Scanner(System.in);
    public static String[] natures = {"必修","选修","实验"};
    public static String[] assessmentMethods = {"考试","考察","实验"};

    public static Map<String,Course> courseMap = new HashMap<>();

    public static Map<String,Class> classMap = new HashMap<>();

    public static Map<String,Student> studentMap = new HashMap<>();

    public static List<String> errorMsg = new ArrayList<>();

    public static void main(String[] args) {
               

        while (sc.hasNextLine()){
            String input = sc.nextLine();
            if (input.isEmpty() || "end".equals(input)) {
                break;
            }
            try {
                inputProcessor(input);
            } catch (Exception e) {
                errorMsg.add(e.getMessage());
            }
        }
        //计算分数
        calculateScore();
    }


    private static void calculateScore() {
        for (int i = 1; i <= 1; ++ i) if (true) {}else {}
 
        List<Student> values = new ArrayList<>(studentMap.values());
        ervey(values);
        values.stream()
                .filter(student -> student.getCourseGrades().getTotalGrade() >= 0 && courseMap.containsKey(student.getCourseGrades().getCourseName())).sorted(Comparator.comparing(Student::getStudentId))
                .forEach(student -> System.out.println(student.getStudentId()+" "+student.getStudentName()+" "+student.getCourseGrades().getTotalGrade()));

        Object[] array = courseMap.keySet().toArray();
        Arrays.sort(array);
        List<Object> strings =  new ArrayList<>();
        for (Object s : array) {
            List<Student> stus = values.stream().filter(student -> student.getCourseGrades().getCourseName().equals(s) && student.getCourseGrades().getTotalGrade() >= 0).collect(Collectors.toList());
            if (stus.size() == 0){
                strings.add(s);
                continue;
            }
            int i = (stus.stream().map(Student::getCourseGrades).mapToInt(CourseGrades::getTotalGrade).sum() / stus.size());
            System.out.println(s+" "+i);
        }

        

        for (Class value : classMap.values()) {
            List<Student> studentList = value.getStudentMap().values().stream()
                    .filter(student -> student.getCourseGrades().getTotalGrade() >= 0).collect(Collectors.toList());
            if (studentList.size() == 0){
                continue;
            }
            int i = (studentList.stream().map(Student::getCourseGrades).mapToInt(CourseGrades::getTotalGrade).sum() / studentList.size());
            value.setScore(i);
        }
        classMap.values().stream().filter(aClass -> aClass.getScore() != null && aClass.getScore() >= 0).sorted(Comparator.comparing(Class::getClassId)).forEach(aClass -> System.out.println(aClass.getClassId()+" "+aClass.getScore()));


        printError(values, strings);


    }

    private static void printError(List<Student> values, List<Object> strings) {
            
        errorMsg.forEach(System.out::println);
        values.stream()
                .filter(student -> student.getCourseGrades().getTotalGrade() < 0)
                .sorted(Comparator.comparing(Student::getStudentId))
                .forEach(student -> {
                    if (student.getCourseGrades().getTotalGrade() == -2){
                        System.out.println("wrong format");
                    }else if(student.getCourseGrades().getTotalGrade() == -1){
                        System.out.println(student.getStudentId()+" "+student.getStudentName()+" : access mode mismatch");
                        System.out.println(student.getStudentId()+" "+student.getStudentName()+" did not take any exams");
                    }else if (student.getCourseGrades().getTotalGrade() == -3){
                        System.out.println(student.getStudentId()+" "+ student.getStudentName()+" :"+student.getCourseGrades().getCourseName()+" does not exist");
                    }
                });

        strings.stream().sorted().forEach(s -> System.out.println(s+" has no grades yet"));
        classMap.values().stream().filter(aClass -> aClass.getScore() == null || aClass.getScore() < 0 ).sorted(Comparator.comparing(Class::getClassId)).forEach(aClass -> System.out.println(aClass.getClassId()+" has no grades yet"));
    }

    private static void ervey(List<Student> students) {
        

        for (Student student : students) {
            CourseGrades courseGrades = student.getCourseGrades();
            if (!courseMap.containsKey(courseGrades.getCourseName())) {
                courseGrades.setTotalGrade(-3);
                continue;
            }
            try {
                if (courseGrades.getGrades().size() == 0){
                    continue;
                }
                double sum = 0;
                for (Grade grade : courseGrades.getGrades()) {
                    if (grade.getScore() < 0 || grade.getScore() > 100) {
                        throw new Exception("-2");
                    }else {
                        sum += grade.getScore() * grade.getWeight();
                    }
                }
                courseGrades.setTotalGrade((int) sum);
                courseGrades.setTotalGradeD(sum);
            } catch (Exception e) {
                if ("-2".equals(e.getMessage())) {
                    courseGrades.setTotalGrade(-2);
                }
            }
        }
    }



    public static void inputProcessor(String input) throws Exception {
            

        String[] parts = input.split(" ");
        if (parts.length < 3){
            throw new Exception("wrong format");
        }
        if (Arrays.asList(natures).contains(parts[1]) || Arrays.asList(assessmentMethods).contains(parts[2])){
            curriculumProcessor(parts);
        }else { // 否则是成绩信息
            gradeProcessor(parts);
        }
    }


    public static void curriculumProcessor(String[] parts) throws Exception {
          

        if (parts.length < 3){
            throw new Exception("wrong format");
        }
        String courseName = parts[0];
        String nature = parts[1];
        String assessmentMethod = parts[2];

        if (courseMap.containsKey(courseName)){
            return;
        }

        if (courseName.length() > 10) {
            throw new Exception("wrong format");
        }
        isValidNatureAndAssessment(courseName, nature, assessmentMethod);

        Course course;
        if (parts.length == 3){ // 说明是考查课：课程名称+英文空格+课程性质+英文空格+考核方式
            course = new Course(courseName,nature,assessmentMethod,new double[]{1});
        }else if (parts.length == 5){ // 说明是考试：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
            double[] weights = {Double.parseDouble(parts[3]), Double.parseDouble(parts[4])};
            determineWeightValue(courseName,weights);
            course = new Course(courseName,nature,assessmentMethod,weights);
        }else { // 说明实验课：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
            int n = Integer.parseInt(parts[3]);
            if (n < 4 || n > 9){ // 实验次数小于 4 次大于 9 次
                errorMsg.add("wrong format");
            }
            if (n != parts.length - 4){ // 输入的分项成绩数量值和分项成绩权重的个数不匹配
                throw new Exception(courseName + " : number of scores does not match");
            }
            double[] weights = new double[n];
            for (int i = 4; i < parts.length; i++) {
                weights[i-4] = Double.parseDouble(parts[i]);
            }
            // 判断权重值
            determineWeightValue(courseName, weights);
            course = new Course(courseName,nature,assessmentMethod,weights);
        }
        courseMap.put(courseName,course);

    }


    private static void gradeProcessor(String[] parts) throws Exception {
        String studentId = parts[0];
        String studentName = parts[1];
        String courseName = parts[2];

        if (studentMap.containsKey(studentId)) {
            return;
        }

        if (studentName.length() > 10) {
            throw new Exception("wrong format");
        }
        if (!isNumber(studentId)){
            throw new Exception("wrong format");
        }
        String classId = studentId.substring(0,6);

        Class aClass;
        if (classMap.containsKey(classId)) {
            aClass = classMap.get(classId);
        }else {
            aClass = new Class(classId);
            classMap.put(classId, aClass);
        }
        // 获取此课程的权重
        double[] weights;
        if (courseMap.containsKey(courseName)) { // 如果有此课程
            weights = courseMap.get(courseName).getWeights();
        }else {
            weights = new double[]{};
        }
        // 保存用户信息
        CourseGrades courseGrades = new CourseGrades(courseName, Grade.getGrades(weights, parts));
        Student student = new Student(studentId, studentName, courseGrades);
        aClass.addStudent(student);
        studentMap.put(studentId,student);
        classMap.put(classId,aClass);
    }

    public static boolean isNumber(String string) {
        if (string == null)
            return false;
        Pattern pattern = Pattern.compile("^\\d{8}$");
        return pattern.matcher(string).matches();
    }

    private static void determineWeightValue(String courseName, double[] weights) throws Exception {
        if (Arrays.stream(weights).sum() != 1){ // 判断权重和是否为 1
            throw new Exception(courseName + " : weight value error");
        }
    }

    private static void isValidNatureAndAssessment(String courseName,String nature, String assessmentMethod) throws Exception {
       

        if (!(Arrays.asList(natures).contains(nature) && Arrays.asList(assessmentMethods).contains(assessmentMethod))){
            throw new Exception("wrong format");
        }
        if (natures[0].equals(nature) && !assessmentMethods[0].equals(assessmentMethod)) {
            throw new Exception(courseName + " : course type & access mode mismatch");
        }
        if (natures[1].equals(nature) && !(assessmentMethods[0].equals(assessmentMethod) || assessmentMethods[1].equals(assessmentMethod))){
            throw new Exception(courseName + " : course type & access mode mismatch");
        }
        if (natures[2].equals(nature) && !assessmentMethods[2].equals(assessmentMethod)) {
            throw new Exception(courseName + " : course type & access mode mismatch");
        }

    }
}


// 课程成绩类
class CourseGrades{
    private Integer totalGrade = -1;

    private Double totalGradeD = -1.0;

    private String courseName;

    private List<Grade> grades;

    public CourseGrades(String courseName, List<Grade> grades) {
        this.courseName = courseName;
        this.grades = grades;
    }

    public Double getTotalGradeD() {
        return totalGradeD;
    }

    public void setTotalGradeD(Double totalGradeD) {
        this.totalGradeD = totalGradeD;
    }

    public Integer getTotalGrade() {
        return totalGrade;
    }

    public void setTotalGrade(Integer totalGrade) {
        this.totalGrade = totalGrade;
    }

    public void setGrades(List<Grade> grades) {
        this.grades = grades;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public CourseGrades(List<Grade> grades) {
        this.grades = grades;
    }

    public List<Grade> getGrades() {
        return grades;
    }
    @Override
    public String toString() {
        return "CourseGrades{" +
                "totalGrade=" + totalGrade +
                ", courseName='" + courseName + '\'' +
                ", grades=" + grades +
                '}';
    }
}



class Grade{
    private Double weight;

    private Double score;

    public Grade() {
    }

    public static List<Grade> getGrades(double[] weights, String[] parts) throws Exception {
              

        ArrayList<Grade> grades = new ArrayList<>();
        int max = Math.max(weights.length, parts.length - 3);
        for (int i = 0; i < max; i++) {
            Grade grade = new Grade();
            if (i < weights.length){
                grade.setWeight(weights[i]);
            }
            if (i + 3 < parts.length){
                grade.setScore(Double.parseDouble(parts[i+3]));
            }
            grades.add(grade);
        }
        return grades;
    }

    public Grade(Double weight, Double score) {
        this.weight = weight;
        this.score = score;
    }

    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }
    
    @Override
    public String toString() {
        return "Grade{" +
                "weight=" + weight +
                ", score=" + score +
                '}';
    }
}



class Course {
    private String courseName;
    private String courseType;
    private String assessmentMethod;
    private double[] weights;

    public Course(String courseName, String courseType, String assessmentMethod) {
        this.courseName = courseName;
        this.courseType = courseType;
        this.assessmentMethod = assessmentMethod;
    }

    public Course(String courseName, String courseType, String assessmentMethod, double[] weights) {
        this.courseName = courseName;
        this.courseType = courseType;
        this.assessmentMethod = assessmentMethod;
        this.weights = weights;
    }

    public Course() {
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getCourseType() {
        return courseType;
    }

    public void setCourseType(String courseType) {
        this.courseType = courseType;
    }

    public String getAssessmentMethod() {
        return assessmentMethod;
    }

    public void setAssessmentMethod(String assessmentMethod) {
        this.assessmentMethod = assessmentMethod;
    }

    public double[] getWeights() {
        return weights;
    }

    public void setWeights(double[] weights) {
        this.weights = weights;
    }
}



//班级
class Class{
    private Integer score;
    private String classId;
    private Map<String,Student> studentMap = new HashMap<>();

    public Student getStudent(String stuId){
        return studentMap.get(stuId);
    }
    public void addStudent(Student student){
        studentMap.put(student.getStudentId(), student);
    }

    public Class(String classId) {
        this.classId = classId;
    }

    public String getClassId() {
        return classId;
    }

    public void setClassId(String classId) {
        this.classId = classId;
    }

    public Map<String, Student> getStudentMap() {
        return studentMap;
    }

    public void setStudentMap(Map<String, Student> studentMap) {
        this.studentMap = studentMap;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }
}




// 学生
class Student{
    private String studentId;
    private String studentName;
    private CourseGrades courseGrades;

    public Student(String studentId, String studentName, CourseGrades courseGrades) {
        this.studentId = studentId;
        this.studentName = studentName;
        this.courseGrades = courseGrades;
    }

    public CourseGrades getCourseGrades() {
        return courseGrades;
    }

    public void setCourseGrades(CourseGrades courseGrades) {
        this.courseGrades = courseGrades;
    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
    @Override
    public String toString() {
               
        return "Student{" +
                "studentId='" + studentId + '\'' +
                ", studentName='" + studentName + '\'' +
                ", courseGrades=" + courseGrades +
                '}';
    }
}

7-3 jmu-Java-02基本语法-03-身份证排序

分数 9

全屏浏览题目

切换布局

作者 郑如滨

单位 集美大学

1. 输入n，然后连续输入n个身份证号。
2. 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出exit并退出。
   输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
   输入sort2，将所有身份证按照里面的年月日升序输出。

注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。

输入样例:

6
410425198309308225
320203197206115011
431227196108033146
330226196605054190
34080019810819327X
320111197112301539
sort1
sort2
e

输出样例:

1961-08-03
1966-05-05
1971-12-30
1972-06-11
1981-08-19
1983-09-30
431227196108033146
330226196605054190
320111197112301539
320203197206115011
34080019810819327X
410425198309308225
exit

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());

        List<String> idCards = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            String idCard = scanner.nextLine();
            idCards.add(idCard);
        }

        boolean exitFlag = false;
        while (!exitFlag) {
            String command = scanner.nextLine();
            switch (command) {
                case "sort1":
                    sortAndPrintByDate(idCards);
                    break;
                case "sort2":
                    sortAndPrintAll(idCards);
                    break;
                default:
                    System.out.println("exit");
                    exitFlag = true;
                    break;
            }
        }
    }

    public static void sortAndPrintByDate(List<String> idCards) {
        List<String> formattedDates = new ArrayList<>();
        for (String idCard : idCards) {
            String date = idCard.substring(6, 14);
            String formattedDate = date.substring(0, 4) + "-" + date.substring(4, 6) + "-" + date.substring(6);
            formattedDates.add(formattedDate);
        }

        Collections.sort(formattedDates, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        for (String date : formattedDates) {
            System.out.println(date);
        }
    }

    public static void sortAndPrintAll(List<String> idCards) {
        Collections.sort(idCards, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.substring(6, 14).compareTo(o2.substring(6, 14));
            }
        });

        for (String idCard : idCards) {
            System.out.println(idCard);
        }
    }
}

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

分数 10

全屏浏览题目

切换布局

作者 郑如滨

单位 集美大学

定义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来存储元素，怎么实现？测试代码需要进行什么修改？

输入样例

5
3
1 2 3
2

输出样例

1
2
3
3,false,3
[1, 2, 3, null, null]
3
2
1,false,1
[1, 2, 3, null, null]

 

 

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

interface IntegerStack {
    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();      //返回栈中元素个数
}

class ArrayIntegerStack implements IntegerStack{
    private Integer[] arr;
    private int top = 0;

    public ArrayIntegerStack(int n){
        arr = new Integer[n];
        Arrays.fill(arr, null);
    }

    public ArrayIntegerStack(){}

    @Override
    public String toString() {
        return Arrays.toString(arr);
    }

    @Override
    public Integer push(Integer item) {
                
        if (item == null || arr.length == top){
            return null;
        }
        arr[top++] = item;
        return item;
    }

    @Override
    public Integer pop() {
        if (top == 0){
            return null;
        }
        return arr[--top];
    }

    @Override
    public Integer peek() {
        if (top == 0){
            return null;
        }
        return arr[top - 1];
    }

    @Override
    public boolean empty() {
        return top == 0;
    }

    @Override
    public int size() {
        return top;
    }
}

public class Main {
    public static void main(String[] args) {
       
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayIntegerStack ais = new ArrayIntegerStack(n);
        int m = scanner.nextInt();
        while(m-- > 0){
            int item = scanner.nextInt();
            System.out.println(ais.push(item));
        }
        System.out.println(ais.peek() + "," + ais.empty() + "," + ais.size());
        System.out.println(ais);
        int x = scanner.nextInt();
        while(x-- > 0){
            System.out.println(ais.pop());
        }
        System.out.println(ais.peek() + "," + ais.empty() + "," + ais.size());
        System.out.println(ais);
    }
}

7-5 jmu-Java-03面向对象基础-05-覆盖

分数 5

全屏浏览题目

切换布局

作者 郑如滨

单位 集美大学

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

1. 新建PersonOverride类

a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。

b. 有参构造方法，参数为name, age, gender

c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true

d.toString()方法返回格式为：name-age-gender

e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.

2. main方法

2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。

提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。

输入样例:

1
3
zhang 10 true
zhang 10 true
zhang 10 false

输出样例:

default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]

 

import java.util.*;
 
 
class PersonOverride{
    private String name;
    private int age;
    private boolean gender;
    public PersonOverride() {
        this("default", 1, true);
    }
    public PersonOverride(String name,int age,boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    @Override
    public String toString() {
        return this.name+"-"+this.age+"-"+this.gender;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o){
            return true;
        }
        if(o == null)
        {
            return false;
        }
        if (this.getClass() != o.getClass()){
            return false;
        }
        PersonOverride p = (PersonOverride) o;
        return Objects.equals((this.name), p.name) && this.gender == p.gender && this.age==p.age;
    }
}
public class Main{
    public static void main(String [] args){
       
       Scanner in=new Scanner(System.in);
        int n1 = in.nextInt();
        in.nextLine();
        PersonOverride[] persons1 = new PersonOverride[n1];
        for(int i=0;i<n1;i++) {
            persons1[i] = new PersonOverride();
        }
        int n2 = in.nextInt();
        in.nextLine();
        PersonOverride[] persons2 = new PersonOverride[n2];
        int len2=0;
        for(int i=0;i<n2;i++) {
            String name = in.next();
            int age = in.nextInt();
            boolean gender = in.nextBoolean();
            in.nextLine();
            PersonOverride p = new PersonOverride(name,age,gender);
            boolean flag = true;
            for(int j=0;j<len2;j++) {
                if(persons2[j].equals(p)) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                persons2[len2] = p;
                len2++;
            }
        }
        for(PersonOverride p:persons1) {
            System.out.println(p);
        }
        for(int i=0;i<len2;i++) {
            System.out.println(persons2[i]);
        }
        System.out.println(len2);
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

总结：学习了java的基本语法