7-8次pta以及期末考试阶段性总结

发布时间 2023-12-08 12:25:46作者: 袁荣皓

1.前言:本次博客主要是对pta-7,pta-8,期末考试的总结与收获。pta7-8考的主要是课程成绩统计程序,主要运用的ArrayList的使用,以及考察类的设计,但是给了类的设计图,把难度减少了许多。总的来说,难度并不是很大。第二次,在课程成绩统计程序1的基础上增加了新的难度,要求计算更多的内容,但是难度较于第一次还是有很大的提升。情况变得更复杂,就需要你的类的设计更加的合理,更有复用性。期末考试的话,难度减少了许多,主要还是对于当前阶段学习状况的一个自我检测和考察,相较于大作业7和8而言还是较为简单的,从我个人而言也能较为独立的完成。

 

2.设计与分析

pta7

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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
代码如下:
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> studentMap = new HashMap<>();

        while (true) 
        {
            String input = scanner.nextLine();
            if (input.equals("end")) 
            {
                break;
            }
            String[] info = input.split(" ");
            studentMap.put(info[0], info[1] + " " + info[2]);
        }

        String sId = scanner.nextLine();
        if (studentMap.containsKey(sId)) 
        {
            System.out.println(sId + " " + studentMap.get(sId));
        } else {
            System.out.println("The student " + sId + " does not exist");
        }
    }
}

 

7-2 容器-HashMap-排序
分数 10
作者 蔡轲
单位 南昌航空大学

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

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

姓名可能会存在重复。

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

输入格式:

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

以“end”为输入结束标志

输出格式:

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

输入样例:

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

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

输出样例:

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

20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.*;

class Sudent 
{
    private String id;
    private String name;
    private int x;
    private int y;
    private int z;
    public void setId(String id) 
    {
        this.id = id;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public void setX(int x) 
    {
        this.x = x;
    }
    public void setY(int y) 
    {
        this.y = y;
    }
    public void setZ(int z) 
    {
        this.z = z;
    }
    public int calculateall() 
    {
        return x + y + z;
    }
    public double calculateAverage() 
    {
        double all = calculateall();
        return (double)(Math.round((all * 100)/ 3)/100.0);
    }

    public String getFee() 
    {
        int all = calculateall();
        double average = calculateAverage();
        return id + " " + name + " " + all + " " + String.format("%.2f", average);
    }
}

public class Main 
{
    public static void main(String[] args) 
    {
        Scanner scanner = new Scanner(System.in);
        HashMap<Integer, String> studentMap = new HashMap<>();

        while (true) 
        {
            String input = scanner.nextLine();
            if (input.equals("end")) 
            {
                break;
            }
            String[] info = input.split(" ");
            int id = Integer.parseInt(info[0]);
            String name = info[1];
            int score = Integer.parseInt(info[2]);
            String studentInfo = name + " " + score;
            studentMap.put(id, studentInfo);
        }

        List<Integer> sortedIds = new ArrayList<>(studentMap.keySet());
        Collections.sort(sortedIds, Collections.reverseOrder());

        for (int id : sortedIds) 
        {
            String studentInfo = studentMap.get(id);
            System.out.println(id + " " + studentInfo);
        }
    }
}

 

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)成绩平均分只取整数部分,小数部分丢弃

参考类图(与第一次相同,其余内容自行补充):


e724fa4193aa9ee32e78a68cd96fd6df_22401e04-c501-4b28-bb65-dabe39d374e7.png

 

输入样例1:

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

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

输出样例1:

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

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

输入样例2:

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

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

输出样例2:

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

wrong format
java has no grades yet

输入样例3:

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

java 必修 实验
20201103 张三 java 3 70 80 90 100
end

输出样例3:

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

java : course type & access mode mismatch
wrong format

输入样例4:

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

java 必修 实验
20201103 张三 java 4 70 80 90 105
end

输出样例4:

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

java : course type & access mode mismatch
wrong format

 

输入样例5:

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

java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end

输出样例5:

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

20201101 王五 76
20201103 张三 85
20201118 郑觉先 80
20201132 王萍 40
20201209 赵仙芝 76
20201213 黄红 82
20201216 李四 78
20201220 朱重九 70
20201302 李梦涵 68
20201307 张少军 83
20201325 崔瑾 82
20201328 刘和宇 77
C语言 65 65
java 78 78
java实验 77
编译原理 81 84 82
202011 70
202012 76
202013 77
代码长度限制
30 KB
时间限制
1000 ms
内存限制
64 MB
 
import java.text.Collator;
import java.util.*;
import java.io.Serializable;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 获取课程信息
        List<Course> courses = new ArrayList<>();
        // 获取选课信息
        List<CurriculaVariable> curriculaVariables = new ArrayList<>();
        // 获取学生信息
//        List<Student> students = new ArrayList<>();
        Map<Integer, String> students = new HashMap<>();

        // 输入的成绩数量和课程的考核方式不匹配
        Map<String, Integer> scoreNumMatchExamType = new HashMap<>();


        // 平时总成绩
        Map<String, Integer> normalPerformance = new HashMap<>();
        // 期末总成绩
        Map<String, Integer> finalGrade = new HashMap<>();
        // 总成绩
        Map<String, Integer> totalScore = new HashMap<>();
        // 实验成绩
        Map<String, Integer> experimentalScore = new HashMap<>();
        // 课程人数
        Map<String, Integer> numberCourses = new HashMap<>();

        // 当前课程是否匹配(根据人名)
        Map<String, Boolean> courseTrueOrFalse = new HashMap<>();
        // 当前课程是否匹配(根据课名)
        Map<String, Boolean> courseTrueOrFalse2 = new HashMap<>();
        // 当前课程是否匹配(根据班级名)
        Map<String, Boolean> courseTrueOrFalse3 = new HashMap<>();

        // 当期前课程类型和考核类型不匹配
        List<String> courseTypeTrueOrFalse = new ArrayList<>();
        // 课程成绩不符合
        List<String> courseFormat = new ArrayList<>();

        // 信息不符合
        Boolean info = false;

        // 创建一个 TreeSet 对象,并传入比较器对象
        Set<String> classSet = new TreeSet<>();

        // 班级总成绩
        Map<String, Integer> classGrade = new HashMap<>();
        // 班级总人数
        Map<String, Integer> classStudentNum = new HashMap<>();
        String content = "";
        //主界面编
        while (!"end".equals(content)) {
            content = sc.nextLine();
            if (!"end".equals(content)) {

                // 根据" "进行分割
                String[] input = content.split(" ");

                // 说明传入的是 课程信息格式
                // 课程名称,课程性质,考核方式
                if (input.length <= 3) {
                    Course course = new Course();
                    // 性质是必须课,可以没有考核方式
                    if (input.length == 2) {
                        // 获取课程名称
                        course.setName(input[0]);
                        // 获取课程性质
                        course.setQuality(input[1]);
                    }else {
                        // 获取课程名称
                        course.setName(input[0]);
                        // 获取课程性质
                        course.setQuality(input[1]);
                        // 获取考核方式
                        course.setType(input[2]);
                        if ("必修".equals(course.getQuality()) && "考察".equals(course.getType())) {
                            courseTypeTrueOrFalse.add(course.getName());
                        }
                        if ("必修".equals(course.getQuality()) && "实验".equals(course.getType())) {
                            courseTypeTrueOrFalse.add(course.getName());
                        }
                        if ("选修".equals(course.getQuality()) && "实验".equals(course.getType())) {
                            courseTypeTrueOrFalse.add(course.getName());
                        }
                        if ("实验".equals(course.getQuality()) && "考试".equals(course.getType())) {
                            courseTypeTrueOrFalse.add(course.getName());
                        }

                    }


                    //添加到课程队列中
                    courses.add(course);

//                System.out.println(input[0] + input[1] + input[2]);
                }

                // 学号, 姓名, 课程名称, 期末成绩
                if(input.length == 4) {
                    Student student = new Student();
                    CurriculaVariable curriculaVariable = new CurriculaVariable();
                    TestScore testScore = new TestScore();
                    Course course = new Course();
                    Score score = new Score();
                    // 获取学号
                    student.setId(Integer.valueOf(input[0]));

                    // 截取学号前六位为班级
                    String idStr = String.valueOf(student.getId());
                    String classNum = idStr.substring(0, 6);

                    // 获取姓名
                    student.setStudentName(input[1]);
                    // 获取课程名称
                    course.setName(input[2]);
                    // 获取期末成绩
                    testScore.setNumber(Integer.valueOf(input[3]));
                    // 计算总成绩
                    score.setNumber(testScore.getNumber());

                    curriculaVariable.setStudent(student);
                    curriculaVariable.setCourse(course);
                    curriculaVariable.setScore(score);

                    if (testScore.getNumber()>100 || testScore.getNumber()<0) {
                        courseFormat.add(course.getName());
                        info = true;
                    }

                    for (Course course1 : courses) {
                        if (course1.getName().equals(course.getName()) && "必修".equals(course1.getQuality())) {
                            courseTrueOrFalse.put(student.getStudentName(), false);
                            courseTrueOrFalse2.put(course1.getName(), false);
                            courseTrueOrFalse3.put(classNum, false);
                        } else {
                            courseTrueOrFalse.put(student.getStudentName(), true);
                            courseTrueOrFalse2.put(course1.getName(), true);
                            courseTrueOrFalse3.put(classNum, true);
                        }
                    }


//                System.out.println(input[0] + input[1] + input[2] + input[3]);
                    // 平时总成绩
                    normalPerformance.put(course.getName(), null);
                    // 期末总成绩
                    finalGrade.put(course.getName(), finalGrade.getOrDefault(course.getName(), 0) + testScore.getNumber());
                    //总成绩
                    totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
                    // 课程人数
                    numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);
                    // 添加学生队列中
                    students.put(student.getId(), student.getStudentName());

                    classSet.add(classNum);
                    // 添加班级总成绩
                    classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
                    // 添加班级总人数
                    classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);

                    // 添加到选修队列中
                    curriculaVariables.add(curriculaVariable);
                }

                // 学号, 姓名, 课程名称, 平时成绩, 期末成绩
                if(input.length == 5) {
                    Student student = new Student();
                    CurriculaVariable curriculaVariable = new CurriculaVariable();
                    TestScore testScore = new TestScore();
                    ReviewScore reviewScore = new ReviewScore();
                    Course course = new Course();
                    Score score = new Score();
                    // 获取学号
                    student.setId(Integer.valueOf(input[0]));

                    // 截取学号前六位为班级
                    String idStr = String.valueOf(student.getId());
                    String classNum = idStr.substring(0, 6);

                    // 获取姓名
                    student.setStudentName(input[1]);
                    // 获取课程名称
                    course.setName(input[2]);
                    // 获取平时成绩
                    reviewScore.setNumber(Integer.valueOf(input[3]));
                    // 获取期末成绩
                    testScore.setNumber(Integer.valueOf(input[4]));
                    // 计算总成绩
                    int tmp = (int) (reviewScore.getNumber()*0.3 + testScore.getNumber()*0.7);
                    score.setNumber(tmp);

                    curriculaVariable.setStudent(student);
                    curriculaVariable.setCourse(course);
                    curriculaVariable.setScore(score);

                    if (testScore.getNumber()>100 || testScore.getNumber()<0 || reviewScore.getNumber()>100 || reviewScore.getNumber()<0) {
                        info = true;
                        courseFormat.add(course.getName());
                    }

//                System.out.println(input[0] + input[1] + input[2] + input[3] + input[4] + " 总成绩为: " + tmp);

                    // 平时成绩
                    normalPerformance.put(course.getName(), normalPerformance.getOrDefault(course.getName(), 0) + reviewScore.getNumber());
                    // 期末总成绩
                    finalGrade.put(course.getName(), finalGrade.getOrDefault(course.getName(), 0) + testScore.getNumber());
                    //总成绩
                    totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
                    // 课程人数
                    numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);

                    // 添加班级总成绩
                    classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
                    // 添加班级总人数
                    classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);

                    classSet.add(classNum);

                    // 添加学生队列中
                    students.put(student.getId(), student.getStudentName());
                    // 添加到选修队列中
                    curriculaVariables.add(curriculaVariable);
                }

                if (input.length<8 && input.length >=6) {
                    Student student = new Student();
                    CurriculaVariable curriculaVariable = new CurriculaVariable();

                    Course course = new Course();
                    Score score = new Score();
                    // 获取学号
                    student.setId(Integer.valueOf(input[0]));

                    // 截取学号前六位为班级
                    String idStr = String.valueOf(student.getId());
                    String classNum = idStr.substring(0, 6);

                    // 获取姓名
                    student.setStudentName(input[1]);
                    // 获取课程名称
                    course.setName(input[2]);
                    // input[3] 为实验次数
                    int num = 0;
                    for (int i = 4; i < input.length; i++) {
                        num += Integer.valueOf(input[i]);
                        if (Integer.valueOf(input[i]) > 100 || Integer.valueOf(input[i]) < 0) {
                            info = true;
                        }
                    }

                    if (Integer.valueOf(input[3]) < 4 || Integer.valueOf(input[3]) > 9) {
                        info = true;
                    }

                    // 添加选修课程数量不一致情况
                    if (Integer.valueOf(input[3]) != input.length-4) {
                        scoreNumMatchExamType.put(student.getStudentName(), scoreNumMatchExamType.getOrDefault(student.getStudentName(), 0) + 1);
                    }

                    courseTrueOrFalse.put(student.getStudentName(), false);

                    // 计算总成绩
                    int tmp = (int) (num / Integer.valueOf(input[3]));
                    score.setNumber(tmp);

                    curriculaVariable.setStudent(student);
                    curriculaVariable.setCourse(course);
                    curriculaVariable.setScore(score);


//                System.out.println(input[0] + input[1] + input[2] + input[3] + input[4] + " 总成绩为: " + tmp);

                    //总成绩
                    totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
                    //实验成绩
                    experimentalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());

                    // 课程人数
                    numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);

                    // 添加班级总成绩
                    classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
                    // 添加班级总人数
                    classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);

                    classSet.add(classNum);




                    // 平时成绩
                    normalPerformance.put(course.getName(), null);
                    // 期末总成绩
                    finalGrade.put(course.getName(), null);
                    //总成绩
                    totalScore.put(course.getName(), null);

                    // 添加学生队列中
                    students.put(student.getId(), student.getStudentName());
                    // 添加到选修队列中
                    curriculaVariables.add(curriculaVariable);
                    if (Integer.valueOf(input[3]) < 4) {
                        info = true;
                    }

                    courseTrueOrFalse3.put(classNum, false);

                }


                // 学号 姓名 课程名称 实验次数 第一次实验成绩+...+英文空格+最后一次实验成绩
                if(input.length >=8 && input.length <= 13) {
                    Student student = new Student();
                    CurriculaVariable curriculaVariable = new CurriculaVariable();

                    Course course = new Course();
                    Score score = new Score();
                    // 获取学号
                    student.setId(Integer.valueOf(input[0]));

                    // 截取学号前六位为班级
                    String idStr = String.valueOf(student.getId());
                    String classNum = idStr.substring(0, 6);

                    // 获取姓名
                    student.setStudentName(input[1]);
                    // 获取课程名称
                    course.setName(input[2]);
                    // input[3] 为实验次数
                    int num = 0;
                    for (int i = 4; i < input.length; i++) {
                        num += Integer.valueOf(input[i]);
                        if (Integer.valueOf(input[i]) > 100 || Integer.valueOf(input[i]) < 0) {
                            info = true;
                        }
                    }

                    if (Integer.valueOf(input[3]) < 4 || Integer.valueOf(input[3]) > 9) {
                        info = true;
                    }

                    // 添加选修课程数量不一致情况
                    if (Integer.valueOf(input[3]) != input.length-4) {
                        scoreNumMatchExamType.put(student.getStudentName(), scoreNumMatchExamType.getOrDefault(student.getStudentName(), 0) + 1);
                    }

                    // 计算总成绩
                    int tmp = (int) (num / Integer.valueOf(input[3]));
                    score.setNumber(tmp);

                    curriculaVariable.setStudent(student);
                    curriculaVariable.setCourse(course);
                    curriculaVariable.setScore(score);


//                System.out.println(input[0] + input[1] + input[2] + input[3] + input[4] + " 总成绩为: " + tmp);

                    //总成绩
                    totalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());
                    //实验成绩
                    experimentalScore.put(course.getName(), totalScore.getOrDefault(course.getName(), 0) + score.getNumber());

                    // 课程人数
                    numberCourses.put(course.getName(), numberCourses.getOrDefault(course.getName(), 0)+1);

                    // 添加班级总成绩
                    classGrade.put(classNum, classGrade.getOrDefault(classNum, 0) + score.getNumber());
                    // 添加班级总人数
                    classStudentNum.put(classNum, classStudentNum.getOrDefault(classNum, 0) + 1);

                    classSet.add(classNum);

                    // 添加学生队列中
                    students.put(student.getId(), student.getStudentName());
                    // 添加到选修队列中
                    curriculaVariables.add(curriculaVariable);


                }

                if(input.length > 13) {
                    info = true;
                }

            }


        }


        Map<Student, Integer> map1 = new HashMap<>();
        for (Map.Entry<Integer, String> entry : students.entrySet()) {
            // 成绩和
            int score = 0;
            // 科目
            int num = 0;
            for (CurriculaVariable curriculaVariable : curriculaVariables) {
                // id 一致说明是一个人
                if (curriculaVariable.getStudent().getId().equals(entry.getKey()) ) {
                    score += curriculaVariable.getScore().getNumber();
                    num ++;
                }
            }
            Student s = new Student();
            s.setStudentName(entry.getValue());
            s.setId(entry.getKey());
            map1.put(s, (int)score/num);
        }
        // 将 Map 转换为 List
        List<Map.Entry<Student, Integer>> list = new ArrayList<>(map1.entrySet());

        // 使用 Collections.sort() 方法对 List 进行排序
        Collections.sort(list, new Comparator<Map.Entry<Student, Integer>>() {
            @Override
            public int compare(Map.Entry<Student, Integer> o1, Map.Entry<Student, Integer> o2) {
                return o1.getKey().getId().compareTo(o2.getKey().getId());
            }
        });


        boolean gradeIsNull = false;

        for (Map.Entry<Student, Integer> entry : list) {
//            Map<String, Boolean> courseTrueOrFalse = new HashMap<>();

            if (!courseFormat.isEmpty()) {
                System.out.println("wrong format");
            }
            else if (!courseTypeTrueOrFalse.isEmpty() && info) {
                for (String str : courseTypeTrueOrFalse) {
                    System.out.println(str + " : course type & access mode mismatch");
                }
            } else if(!courseTypeTrueOrFalse.isEmpty() && !info) {
                for (String str : courseTypeTrueOrFalse) {
                    System.out.println(str + " : course type & access mode mismatch");
                    System.out.println(str+ " does not exist");
                    System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + "did not take any exams");
                    gradeIsNull = true;
                }
            } else if(scoreNumMatchExamType.getOrDefault(entry.getKey().getStudentName(), 0) > 0) {
                System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + ": access mode mismatch");
            }  else if (info) {

            }else {
                if (entry.getValue() == 0 || entry.getValue() == null) {
                    System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + "did not take any exams");
                } else {
                    System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + entry.getValue());
                }
            }

             if (courseTrueOrFalse.getOrDefault(entry.getKey().getStudentName(), true) != true && !info) {

                System.out.println(entry.getKey().getId() + " " + entry.getKey().getStudentName() + " " + "did not take any exams");

            }

        }

        if(info) {
            System.out.println("wrong format");
        }

        Collator collator = Collator.getInstance(Locale.CHINA); // 创建一个中文排序器
        Collections.sort(courses, new Comparator<Course>() {
            @Override
            public int compare(Course c1, Course c2) {
                return collator.compare(c1.getName(), c2.getName());
            }
        });


            for (Course course : courses) {
            // 总人数
            Integer num = numberCourses.get(course.getName());

            if (!courseFormat.isEmpty()) {
                for (String tmp : courseFormat) {
                    System.out.println(tmp + " has no grades yet");
                }
            } else if (!courseTypeTrueOrFalse.isEmpty()) {  // 如果某门课程没有任何成绩信息,输出: 课程名称+英文空格+"has no grades yet"

            } else if (normalPerformance.get(course.getName()) == null && finalGrade.get(course.getName()) == null && totalScore.get(course.getName()) == null) {
                System.out.println(course.getName() + " " + "has no grades yet");
            } else if (courseTrueOrFalse2.getOrDefault(course.getName(), true) != true) {
                System.out.println(course.getName() + " " + "has no grades yet");
            }else {

                Integer normalPerformance1 = null;

                // 期末成绩
                int finalGrade1;
                // 总成绩
                int numberCourses1;

                if (normalPerformance.get(course.getName()) == null && experimentalScore.get(course.getName()) == null) {
                    // 期末成绩
                    finalGrade1 = (int)finalGrade.get(course.getName())/num;
                    // 总成绩
                    numberCourses1 = (int) totalScore.get(course.getName())/num;

                    System.out.println(course.getName() + " " + finalGrade1 + " " + numberCourses1);
                } else if (experimentalScore.get(course.getName()) != null) { // 是实验课
                    numberCourses1 = (int) totalScore.get(course.getName())/num;
                    System.out.println(course.getName() + " " + numberCourses1);

                } else {
                    // 期末成绩
                    finalGrade1 = (int)finalGrade.get(course.getName())/num;
                    // 总成绩
                    numberCourses1 = (int) totalScore.get(course.getName())/num;

                    // 平时成绩
                    normalPerformance1 = (int)normalPerformance.get(course.getName())/num;
                    System.out.println(course.getName() + " " + normalPerformance1 + " " + finalGrade1 + " " + numberCourses1);
                }

            }

        }

        if (!info) {
            for (String className : classSet) {
                if (!courseFormat.isEmpty()) {

                } else if (!courseTypeTrueOrFalse.isEmpty()) {
                    System.out.println(className + " " + "has no grades yet");
                } else if (classGrade.get(className) != null && courseTrueOrFalse3.getOrDefault(className, true) == true) {
                    int classScore = (int)classGrade.get(className)/classStudentNum.get(className);
                    System.out.println(className + " " + classScore);
                }else {
                    System.out.println(className + " " + "has no grades yet");

                }

            }
        }



    }
}
class Class implements Serializable {
    private Integer id;
    private String className;

    public Class() {
    }

    public Class(Integer id, String className) {
        this.id = id;
        this.className = className;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}
class Course implements Serializable {
    // ID
    private Integer id;
    private String name;
    // 课程性质
    private String quality;
    // 考核方式
    private String type;

    public Course() {
    }

    public Course(Integer id, String name, String quality, String type) {
        this.id = id;
        this.name = name;
        this.quality = quality;
        this.type = type;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getQuality() {
        return quality;
    }

    public void setQuality(String quality) {
        this.quality = quality;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}
class CurriculaVariable {
    // 课程
    private Course course;
    // 学生
    private Student student;
    // 成绩
    private Score score;

    public CurriculaVariable() {
    }

    public CurriculaVariable(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }
}
class ReviewScore extends Score{
}
class Score implements Serializable {
    private Integer number;

    public Score(Integer number) {
        this.number = number;
    }

    public Score() {
    }

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }
}
class Student implements Serializable {
    // 学号
    private Integer id;
    // 姓名
    private String studentName;
    // 学生专业
    private String major;
    // 学生班级
    private Class aClass;

    public Student() {
    }

    public Student(Integer id, String studentName, String major, Class aClass) {
        this.id = id;
        this.studentName = studentName;
        this.major = major;
        this.aClass = aClass;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public Class getaClass() {
        return aClass;
    }

    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }
}
class TestScore extends Score{
}

 

 

 

 本题对于我而言还是比较困难的,我一开始也很难以下手,在多次测试和运行后仍然存在不少的错误还有待提高和改进。

 

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 【】{
    【】
    【】
}

输入样例:

 

输出样例:

猫的叫声:喵喵
狗的叫声:汪汪
山羊的叫声:咩咩
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
 
//动物发生模拟器.  请在下面的【】处添加代码。
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
{
    public String getAnimalClass()
    {
        return "猫";
    }
    public String shout()
    {
        return "喵喵";
    }
}

//基于Animal类,定义狗类Dog,并重写两个抽象方法
class Dog extends Animal
{
    public String getAnimalClass()
    {
        return "狗";
    }
    public String shout()
    {
        return "汪汪";
    }
}

//基于Animal类,定义山羊类Goat,并重写两个抽象方法
class Goat extends Animal
{
    public String getAnimalClass()
    {
        return "山羊";
    }
    public String shout()
    {
    return "咩咩";
    }
}

 

pta8

7-1 容器-ArrayList-排序
分数 12
作者 蔡轲
单位 南昌航空大学

题目描述

编辑

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

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

姓名可能会存在重复。

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

输入格式:

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

以“end”为输入结束标志

输出格式:

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

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

输入样例:

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

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

输出样例:

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

20201136 李四 164
20201124 张少军 158
20201118 郑觉先 142
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main 
{
    public static void main(String[] args) 
    {
        Scanner sc = new Scanner(System.in);
        ArrayList<Student> list = new ArrayList<>();
        String input = sc.nextLine();
        while (!input.equals("end")) 
        {
            String[] arr = input.split(" ");
            int id = Integer.parseInt(arr[0]);
            String name = arr[1];
            int mathScore = Integer.parseInt(arr[2]);
            int physicsScore = Integer.parseInt(arr[3]);
            Student stu = new Student(id, name, mathScore, physicsScore);
            list.add(stu);
            input = sc.nextLine();
        }
        Collections.sort(list, new Comparator<Student>() 
                         {
            public int compare(Student o1, Student o2) 
            {
                int sum1 = o1.getMathScore() + o1.getPhysicsScore();
                int sum2 = o2.getMathScore() + o2.getPhysicsScore();
                if (sum2 != sum1) 
                {
                    return sum2 - sum1;
                } 
                else 
                {
                    return list.indexOf(o1) - list.indexOf(o2);
                }
            }
        });
        for (Student stu : list) 
        {
            System.out.println(stu.getId() + " " + stu.getName() + " " + (stu.getMathScore() + stu.getPhysicsScore()));
        }
    }
}

class Student 
{
    private int id;
    private String name;
    private int mathScore;
    private int physicsScore;

    public Student(int id, String name, int mathScore, int physicsScore) {
        this.id = id;
        this.name = name;
        this.mathScore = mathScore;
        this.physicsScore = physicsScore;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public int getMathScore() {
        return mathScore;
    }
    public int getPhysicsScore() {
        return physicsScore;
    }
}
class Sudent 
{
    private String id;
    private String name;
    private int x;
    private int y;
    private int z;
    public void setId(String id) 
    {
        this.id = id;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public void setX(int x) 
    {
        this.x = x;
    }
    public void setY(int y) 
    {
        this.y = y;
    }
    public void setZ(int z) 
    {
        this.z = z;
    }
    public int calculateall() 
    {
        return x + y + z;
    }
    public double calculateAverage() 
    {
        double all = calculateall();
        return (double)(Math.round((all * 100)/ 3)/100.0);
    }

    public String getFee() 
    {
        int all = calculateall();
        double average = calculateAverage();
        return id + " " + name + " " + all + " " + String.format("%.2f", average);
    }
}
class Su1dent 
{
    private String id;
    private String name;
    private int x;
    private int y;
    private int z;
    public void setId(String id) 
    {
        this.id = id;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public void setX(int x) 
    {
        this.x = x;
    }
    public void setY(int y) 
    {
        this.y = y;
    }
    public void setZ(int z) 
    {
        this.z = z;
    }
    public int calculateall() 
    {
        return x + y + z;
    }
    public double calculateAverage() 
    {
        double all = calculateall();
        return (double)(Math.round((all * 100)/ 3)/100.0);
    }

    public String getFee() 
    {
        int all = calculateall();
        double average = calculateAverage();
        return id + " " + name + " " + all + " " + String.format("%.2f", average);
    }
}

 

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)成绩平均分只取整数部分,小数部分丢弃

参考类图(与第一次相同,其余内容自行补充):

fdada4ca193119ee30531ab82ffebbfa_9dbcf4e8-1627-4cf6-8764-cccf44947e2a.png

输入样例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
代码长度限制
25 KB
时间限制
1500 ms
内存限制
64 MB

 

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

class Course {
    String name;
    String nature;
    String assessment;
    int weightGradeLength;
    String[] weightGrade;
    boolean isValid = true;

    public Course(String name, String nature, String assessment, int weightGradeLength, String[] weightGrade) {
        this.name = name;
        this.nature = nature;
        this.assessment = assessment;
        this.weightGradeLength = weightGradeLength;
        this.weightGrade = weightGrade;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Course course = (Course) o;
        return isValid == course.isValid && Objects.equals(name, course.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, isValid);
    }
}

class Score {
    String courseName;
    String studentId;
    String[] scores;
    boolean isValid = true;

    public Score(String courseName, String studentId, String[] scores) {
        this.courseName = courseName;
        this.studentId = studentId;
        this.scores = scores;
    }

    /**
     * 获取学生此课程的成绩
     *
     * @param weighs 权重
     * @return 分数
     */
    double getScore(String[] weighs) {
        double result = 0.0;
        for (int i = 0; i < weighs.length; i++) {
            double weigh = Double.parseDouble(weighs[i]);
            double score = Double.parseDouble(scores[i]);
            result += score * weigh;
        }
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Score baseScore = (Score) o;
        return Objects.equals(courseName, baseScore.courseName) && Objects.equals(studentId, baseScore.studentId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(courseName, studentId);
    }
}

class Student {
    String id;
    String name;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

class Class {
    String id;
    int length = 1;
    double result = 0;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Class aClass = (Class) o;
        return Objects.equals(id, aClass.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

/**
 * @author tu
 */
public class Main {
    static final Scanner INPUT = new Scanner(System.in);
    static final Set<Course> COURSE_SET = new HashSet<>();
    static final Set<Student> STUDENT_SET = new HashSet<>();
    static final Set<Class> CLASS_SET = new HashSet<>();
    static final Set<Score> SCORE_SET = new HashSet<>();

    public static List<Student> findStudentByPrefixId(String id) {
        List<Student> result = new ArrayList<>();
        for (Student student : STUDENT_SET) {
            if (student.id.substring(0, 6).equals(id)) {
                result.add(student);
            }
        }
        return result;
    }

    public static Student findStudentById(String id) {
        Student result = null;
        for (Student student : STUDENT_SET) {
            if (student.id.equals(id)) {
                result = student;
                break;
            }
        }
        return result;
    }

    public static List<Score> findScoreByStudentId(String id) {
        List<Score> result = new ArrayList<>();
        for (Score score : SCORE_SET) {
            if (score.studentId.equals(id)) {
                result.add(score);
            }
        }
        return result;
    }

    public static List<Score> findScoreByCourseName(String courseName) {
        List<Score> result = new ArrayList<>();
        for (Score score : SCORE_SET) {
            if (score.courseName.equals(courseName)) {
                result.add(score);
            }
        }
        return result;
    }

    public static Course findCourseByName(String name, boolean isValid) {
        Course result = null;
        for (Course course : COURSE_SET) {
            if (course.name.equals(name) && course.isValid == isValid) {
                result = course;
                break;
            }
        }
        return result;
    }

    public static void dealWithCourse() {
        //    3)如果解析某个课程信息时,输入的课程性质和课程的考核方式不匹配,输出:课程名称+" : course type & access mode mismatch"
        //    6)如果解析实验课程信息时,输入的分项成绩数量值和分项成绩权重的个数不匹配,输出:课程名称+" : number of scores does not match"
        //    7)如果解析考试课、实验课时,分项成绩权重值的总和不等于1,输出:课程名称+" : weight value error"
        for (Course course : COURSE_SET) {
            if ("选修".equals(course.nature) && "实验".equals(course.assessment)) {
                course.isValid = false;
            } else if ("必修".equals(course.nature) && !"考试".equals(course.assessment)) {
                course.isValid = false;
            } else if ("实验".equals(course.nature) && !"实验".equals(course.assessment)) {
                course.isValid = false;
            }
            if (!course.isValid) {
                System.out.println(course.name + " : course type & access mode mismatch");
                continue;
            }

            if (course.weightGrade.length != course.weightGradeLength) {
                System.out.println(course.name + " : number of scores does not match");
                course.isValid = false;
                continue;
            }

            double weight = 0.0;
            for (String s : course.weightGrade) {
                weight += Double.parseDouble(s);
            }
            if (weight != 0 && (int) weight != 1) {
                System.out.println(course.name + " : weight value error");
                course.isValid = false;
            }
        }
    }

    public static void dealWitScore() {
        //    1)如果解析某个成绩信息时,课程名称不在已输入的课程列表中,输出:学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
        //    2)如果解析某个成绩信息时,输入的成绩数量和课程的考核方式不匹配,输出:学号+英文空格+姓名+英文空格+": access mode mismatch"
        //    以上两种情况如果同时出现,按第一种情况输出结果。
        //    4)格式错误以及其他信息异常如成绩超出范围等,均按格式错误处理,输出"wrong format"
        //    必修、选修、实验
        //    考试、考察、实验
        for (Score baseScore : SCORE_SET) {
            Student student = findStudentById(baseScore.studentId);
            Course course = findCourseByName(baseScore.courseName, true);
            if (course == null) {
                System.out.println(baseScore.courseName + " does not exist");
                baseScore.isValid = false;
                continue;
            } else {
                if ("选修".equals(course.nature) && baseScore.scores.length > 1) {
                    baseScore.isValid = false;
                } else if ("必修".equals(course.nature) && baseScore.scores.length != 2) {
                    baseScore.isValid = false;
                } else if ("实验".equals(course.nature)) {
                    if (baseScore.scores.length < 4 || baseScore.scores.length > 9 || course.weightGradeLength != baseScore.scores.length) {
                        baseScore.isValid = false;
                    }
                }
                if (!baseScore.isValid) {
                    System.out.println(student.id + " " + student.name + " : access mode mismatch");
                    baseScore.isValid = false;
                    continue;
                }
            }
            for (String score : baseScore.scores) {
                int i = Integer.parseInt(score);
                if (i < 0 || i > 100) {
                    System.out.println("wrong format");
                }
            }
        }
    }

    public static void resultStudent() {
        //    为避免四舍五入误差,计算单个成绩时,分项成绩乘以权重后要保留小数位,计算总成绩时,累加所有分项成绩的权重分以后,再去掉小数位。
        //    学生总成绩/整个班/课程平均分的计算方法为累加所有符合条件的单个成绩,最后除以总数。

        //    1)学生课程总成绩平均分按学号由低到高排序输出
        //    格式:学号+英文空格+姓名+英文空格+总成绩平均分
        //    如果某个学生没有任何成绩信息,输出:学号+英文空格+姓名+英文空格+"did not take any exams"
        List<StudentScore> studentScores = new ArrayList<>();
        for (Student student : STUDENT_SET) {
            double result = 0.0;
            int length = 0;
            List<Score> scoreList = findScoreByStudentId(student.id);
            for (Score score : scoreList) {
                if (score.isValid) {
                    Course course = findCourseByName(score.courseName, true);
                    if (course != null && course.isValid) {
                        result += Math.floor(score.getScore(course.weightGrade));
                        length++;
                    }
                }
            }
            studentScores.add(new StudentScore(result, student, length));
        }
        studentScores.sort(Comparator.comparingInt(student -> Integer.parseInt(student.student.id)));
        for (StudentScore studentScore : studentScores) {
            if (studentScore.result == 0) {
                System.out.println(studentScore.student.id + " " + studentScore.student.name + " did not take any exams");
            } else {
                int result = (int) Math.floor(studentScore.result / studentScore.length);
                System.out.println(studentScore.student.id + " " + studentScore.student.name + " " + result);
            }
        }
    }

    public static void resultCourse() {
        //    2)单门课程成绩按课程名称的字符顺序输出
        //    课程成绩输出格式:课程名称+英文空格+总成绩平均分
        //    如果某门课程没有任何成绩信息,输出:课程名称+英文空格+"has no grades yet"
        List<CourseScore> courseScores = new ArrayList<>();
        for (Course course : COURSE_SET) {
            if (course.isValid) {
                double result = 0.0;
                int length = 0;
                List<Score> scoreList = findScoreByCourseName(course.name);
                for (Score score : scoreList) {
                    if (score.isValid) {
                        result += Math.floor(score.getScore(course.weightGrade));
                        length++;
                    }
                }
                courseScores.add(new CourseScore(result, course, length));
            }
        }
        courseScores.sort(new ChineseComparator());
        for (CourseScore courseScore : courseScores) {
            if (courseScore.result == 0) {
                System.out.println(courseScore.course.name + " has no grades yet");
            } else {
                int result = (int) Math.floor(courseScore.result / courseScore.length);
                System.out.println(courseScore.course.name + " " + result);
            }
        }
    }

    public static void resultClass() {
        //    3)班级所有课程总成绩平均分按班级由低到高排序输出
        //    格式:班级号+英文空格+总成绩平均分
        //    如果某个班级没有任何成绩信息,输出:班级名称+英文空格+ "has no grades yet"
        for (Class aClass : CLASS_SET) {
            double result = 0.0;
            int length = 0;
            List<Student> studentByPrefixId = findStudentByPrefixId(aClass.id);
            for (Student student : studentByPrefixId) {
                List<Score> scoreList = findScoreByStudentId(student.id);
                Set<Course> courses = new HashSet<>();
                for (Score score : scoreList) {
                    if (score.isValid) {
                        Course course = findCourseByName(score.courseName, true);
                        if (course != null && course.isValid) {
                            courses.add(course);
                            result += Math.floor(score.getScore(course.weightGrade));
                        }
                    }
                }
                for (Course course : courses) {
                    if (course.isValid) {
                        length++;
                    }
                }
            }
            aClass.result = result;
            aClass.length = length;
        }

        // 将 HashSet 转换成按照 id 字段升序排序的列表
        List<Class> sortedList = CLASS_SET.stream()
                .sorted(Comparator.comparingInt((Class c) -> Integer.parseInt(c.id)))
                .collect(Collectors.toList());

        for (Class aClass : sortedList) {
            if (aClass.result == 0) {
                System.out.println(aClass.id + " has no grades yet");
            } else {
                int result = (int) Math.floor(aClass.result / aClass.length);
                System.out.println(aClass.id + " " + result);
            }
        }
    }

    public static boolean isNumeric(String str) {
        try {
            Integer.parseInt(str);
            return true;
        } catch (NumberFormatException e) {
            // 如果发生异常,表示无法转换为数字
            return false;
        }
    }

    public static void main(String[] args) {
        String value;
        String terminator = "end";
        //     考试课信息格式:课程名称+课程性质+考核方式+平时成绩的权重+期末成绩的权重
        //     考察课信息格式:课程名称+课程性质+考核方式
        //   实验课程信息格式:课程名称+课程性质+考核方式+分项成绩数量n+分项成绩1的权重+英文空格+...+分项成绩n的权重

        //考试/考查课程成绩信:学号+姓名+课程名称+平时成绩+期末成绩
        //  实验课程信息格式:学号+姓名+课程名称+第一次实验成绩+...+最后一次实验成绩
        try {
            value = INPUT.nextLine();
            while (!terminator.equals(value)) {
                String[] values = value.split(" ");
                int valuesLength = values.length;
                //    5)若出现重复的课程/成绩信息,只保留第一个课程信息,忽略后面输入的。
                if (isNumeric(values[0])) {
                    String substring = values[0].substring(0, 6);
                    Class aClass = new Class(substring);
                    CLASS_SET.add(aClass);

                    Student student = new Student(values[0], values[1]);
                    STUDENT_SET.add(student);

                    String[] score = new String[valuesLength - 3];
                    System.arraycopy(values, 3, score, 0, valuesLength - 3);
                    Score experimentScore = new Score(values[2], values[0], score);
                    SCORE_SET.add(experimentScore);
                } else {
                    Course course;
                    if (valuesLength == 3) {
                        course = new Course(values[0], values[1], values[2], 1, new String[]{"1"});
                        if ("选修".equals(values[1]) && "实验".equals(values[2])) {
                            course.isValid = false;
                        }
                    } else if ("必修".equals(values[1])) {
                        course = new Course(values[0], values[1], values[2], 2, new String[]{values[3], values[4]});
                    } else {
                        String[] score = new String[valuesLength - 4];
                        System.arraycopy(values, 4, score, 0, valuesLength - 4);
                        course = new Course(values[0], values[1], values[2], Integer.parseInt(values[3]), score);
                    }
                    COURSE_SET.add(course);
                }
                value = INPUT.nextLine();
            }
        } finally {
            INPUT.close();
        }
        dealWithCourse();
        dealWitScore();
        resultStudent();
        resultCourse();
        resultClass();
    }

    static class StudentScore {
        double result;
        Student student;
        int length;

        public StudentScore(double result, Student student, int length) {
            this.result = result;
            this.student = student;
            this.length = length;
        }
    }

    static class CourseScore {
        double result;
        Course course;
        int length;

        public CourseScore(double result, Course course, int length) {
            this.result = result;
            this.course = course;
            this.length = length;
        }
    }

    static class ChineseComparator implements Comparator<CourseScore> {
        @Override
        public int compare(CourseScore courseScore1, CourseScore courseScore2) {
            return courseScore1.course.name.compareTo(courseScore2.course.name);
            // 或者使用以下方法来忽略大小写并进行中文比较
            // return Collator.getInstance(Locale.CHINA).compare(student1.getName(), student2.getName());
        }
    }
}

 这道题我已经尽我所能了,实在是对于这个错误真的是无法下手,感觉都考虑到了但是就是跑不出来,最后无奈选择放弃了,希望以后有更好的提高的突破

 

7-3 jmu-Java-02基本语法-03-身份证排序
分数 9
作者 郑如滨
单位 集美大学
  1. 输入n,然后连续输入n个身份证号。
  2. 然后根据输入的是sort1还是sort2,执行不同的功能。输入的不是sort1或sort2,则输出exit并退出。
    输入sort1,将每个身份证的年月日抽取出来,按年-月-日格式组装,然后对组装后的年-月-日升序输出。
    输入sort2,将所有身份证按照里面的年月日升序输出。

注意:处理输入的时候,全部使用ScannernextLine()方法,以免出错。

输入样例:

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

代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int count=Integer.valueOf(sc.nextLine());
        String s[]=new String[count];
        for (int i=0;i<count;i++){
            s[i]=sc.nextLine();
        }
        String temp;
        SimpleDateFormat df=new SimpleDateFormat("yyyyMMdd");
        while (true){
            String tem=sc.nextLine();
            if (tem.equals("sort1")){
                Date date[]=new Date[count];
                for (int j=0;j<count;j++){
                    for (int i=0;i<count-j-1;i++){
                        String bir1=s[i].substring(6,14);
                        String bir2=s[i+1].substring(6,14);
                        Date d1;
                        Date d2;
                        try {
                            d1 = df.parse(bir1);
                            d2 =df.parse(bir2);
                            if (d1.getTime()>d2.getTime()){
                                temp=s[i];
                                s[i]=s[i+1];
                                s[i+1]=temp;
                            }
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                    }
                }
                for (int i=0;i<count;i++){
                    String bir=s[i];
                    System.out.println(bir.substring(6,10)+"-"+bir.substring(10,12)+"-"+bir.substring(12,14));
                }
            }else if (tem.equals("sort2")){
                Date date[]=new Date[count];
                for (int j=0;j<count;j++){
                    for (int i=0;i<count-j-1;i++){
                        String bir1=s[i].substring(6,14);
                        String bir2=s[i+1].substring(6,14);
                        Date d1;
                        Date d2;
                        try {
                            d1 = df.parse(bir1);
                            d2 =df.parse(bir2);
                            if (d1.getTime()>d2.getTime()){
                                temp=s[i];
                                s[i]=s[i+1];
                                s[i+1]=temp;
                            }
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                    }
                }
                for (int i=0;i<count;i++){
                    System.out.println(s[i]);
                }
            }else {
                System.out.println("exit");
            }
        }
    }
}
class Time implements Comparable<Time> {
    private String year;
    private String month;
    private String day;
    public Time(String year, String month, String day) {
        super();
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public String getYear() {
        return year;
    }
    public void setYear(String year) {
        this.year = year;
    }
    public String getMonth() {
        return month;
    }
    public void setMonth(String month) {
        this.month = month;
    }
    public String getDay() {
        return day;
    }
    public void setDay(String day) {
        this.day = day;
    }
    public Time() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int compareTo(Time o) {
        // TODO Auto-generated method stub
        int a =Integer.parseInt(this.year);
        int b =Integer.parseInt(o.year);
        return a-b;
    }
}
class ID implements Comparable<ID>{
    private String id;
    private String judge;
    public ID() {
        super();
        // TODO Auto-generated constructor stub
    }
    public ID(String id, String judge) {
        super();
        this.id = id;
        this.judge = judge;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getJudge() {
        return judge;
    }
    public void setJudge(String judge) {
        this.judge = judge;
    }
    public int compareTo(ID o) {
        // TODO Auto-generated method stub
        int a =Integer.parseInt(this.judge);
        int b =Integer.parseInt(o.judge);
        return a-b;
    }
}
class Sudent 
{
    private String id;
    private String name;
    private int x;
    private int y;
    private int z;
    public void setId(String id) 
    {
        this.id = id;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public void setX(int x) 
    {
        this.x = x;
    }
    public void setY(int y) 
    {
        this.y = y;
    }
    public void setZ(int z) 
    {
        this.z = z;
    }
    public int calculateall() 
    {
        return x + y + z;
    }
    public double calculateAverage() 
    {
        double all = calculateall();
        return (double)(Math.round((all * 100)/ 3)/100.0);
    }

    public String getFee() 
    {
        int all = calculateall();
        double average = calculateAverage();
        return id + " " + name + " " + all + " " + String.format("%.2f", average);
    }
}
class Su2dent 
{
    private String id;
    private String name;
    private int x;
    private int y;
    private int z;
    public void setId(String id) 
    {
        this.id = id;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public void setX(int x) 
    {
        this.x = x;
    }
    public void setY(int y) 
    {
        this.y = y;
    }
    public void setZ(int z) 
    {
        this.z = z;
    }
    public int calculateall() 
    {
        return x + y + z;
    }
    public double calculateAverage() 
    {
        double all = calculateall();
        return (double)(Math.round((all * 100)/ 3)/100.0);
    }

    public String getFee() 
    {
        int all = calculateall();
        double average = calculateAverage();
        return id + " " + name + " " + all + " " + String.format("%.2f", average);
    }
}

 

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]

代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.*;

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(){}

    public String toString() {

        return Arrays.toString(arr);

    }

    public Integer push(Integer item) {

        if (item == null || arr.length == top){

            return null;

        }

        arr[top++] = item;

        return item;

    }

    public Integer pop() {

        if (top == 0){

            return null;

        }

        return arr[--top];

    }

    public Integer peek() {

        if (top == 0){

            return null;

        }

        return arr[top - 1];

    }

    public boolean empty() {

        return top == 0;

    }

    public int size() {

        return top;

    }

}

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        ArrayIntegerStack a = new ArrayIntegerStack(n);

        int m = in.nextInt();

        while(m-- > 0){

            int item = in.nextInt();

            System.out.println(a.push(item));

        }

        System.out.println(a.peek() + "," + a.empty() + "," + a.size());

        System.out.println(a);

        int x = in.nextInt();

        while(x-- > 0){

            System.out.println(a.pop());

        }

        System.out.println(a.peek() + "," + a.empty() + "," + a.size());

        System.out.println(a);

    }

}
7-5 jmu-Java-03面向对象基础-05-覆盖
分数 5
作者 郑如滨
单位 集美大学

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

1. 新建PersonOverride类

a. 属性:String nameint ageboolean 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)]

代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.*;
class PersonOverride{
    private String name;
    private int age;
    private boolean gender;
    public String toString() 
    {
        return name + "-" + age + "-" + gender;
    }
    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;
        boolean a1 = Objects.equals((this.name), p.name);
        boolean a2 = (this.age == p.age);
        boolean a3 = (this.gender == p.gender);
        if(a1 && a2 && a3)
        {
            return true;
        }
        return false;
    }
    public PersonOverride(String _name, int _age, boolean _gender){
        name = _name;
        age = _age;
        gender = _gender;
    }
    public PersonOverride(){
        this("default",1,true);
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int i,count = 0;
        int n1 = in.nextInt();
        PersonOverride[] person1 = new PersonOverride[n1];
        for (i = 0; i < n1; i++) {
            person1[i] = new PersonOverride();
        }
        int n2 = in.nextInt();
        in.nextLine();
        PersonOverride[] person2 = new PersonOverride[n2];
        for (i = 0; i < n2; i++) {
            String str = in.nextLine();
            String[] arr = str.split("\\s+");
            PersonOverride temp = new PersonOverride(arr[0],Integer.parseInt(arr[1]),Boolean.valueOf(arr[2]));
            boolean f = true;
            for (int j = 0; j < n2; j++) {
                if(temp.equals(person2[j])){
                    f = false;
                }
            }
            if(f){
                person2[i] = new PersonOverride(arr[0],Integer.parseInt(arr[1]),Boolean.valueOf(arr[2]));
            }
        }
        for ( i = 0; i < n1; i++) {
            System.out.println(person1[i]);
        }
        for (i = 0; i < n2; i++) {
            if(person2[i] == null){
                continue;
            }
            count++;
            System.out.println(person2[i]);
        }
        System.out.println(count);
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

 

期末考试:

分数 2
作者 刘凤良
单位 天津仁爱学院

给出以下一些代码,请问以下哪些描述是正确的?

 
public  XXXX extends something1,something2 { ...... }
A.

如果 XXXX 是一个接口,something和something2取消掉,则代码段合法。

B.

如果 XXXX 是一个类,something和something2均是接口,则代码段合法。

C.

如果 XXXX 、something和something2均是接口,则代码段合法。

D.

因为Java语言不支持多重继承机制,所以代码段不合法。

 
答案错误:0 分

2-2
分数 1
作者 马俊
单位 兰州大学

Java中关于方法覆盖的描述,下面错误的是?

A.

覆盖包括方法的覆盖和成员变量的覆盖

B.

成员方法的覆盖是多态的一种表现形式

C.

子类可以调用父类中被覆盖的方法

D.

任何方法都可以被覆盖

 
答案正确:1 分

2-3
分数 1
作者 马俊
单位 兰州大学

下列Java程序的输出结果是?

class F{ 
    public F(){ System.out.print("F() is called!"); } 
} 
class S extends F{ 
    public S(){ System.out.print("S() is called!"); } 
} 
public class Test{ 
    public static void main(String args[]){ 
        S sa=new S(); 
    } 
}


A.

F() is called!

B.

S() is called!

C.

F() is called! S() is called!

D.

S() is called! F() is called!

 
答案正确:1 分

2-4
分数 1
作者 马俊
单位 兰州大学

Java中关于抽象类的描述,错误的是?

A.

抽象类中只有抽象方法

B.

用abstract修饰的类是抽象类

C.

抽象方法没有方法体

D.

抽象类不能用来实例化对象

 
答案正确:1 分

2-5
分数 1
作者 马俊
单位 兰州大学

Java中,如果类C是类B的子类,类B是类A的子类,那么下面描述正确的是?

A.

C不仅继承了B中的成员,同样也继承了A中的成员

B.

C只继承了B中的成员

C.

C只继承了A中的成员

D.

C不能继承A或B中的成员

 
答案正确:1 分

2-6
分数 1
作者 马俊
单位 兰州大学

在Java中,所有类的根类是?

A.

java.lang.Class

B.

java.lang.Object

C.

java.applet.Applet

D.

java.awt.Frame

 
答案正确:1 分

2-7
分数 1
作者 马俊
单位 兰州大学

在Java中能实现多重继承效果的方式是?

A.

内部类

B.

适配器

C.

接口

D.

多线程

 
答案正确:1 分

2-8
分数 1
作者 马俊
单位 兰州大学

Java语言中,以下关于覆盖与重载说法正确的是?

A.

覆盖只有发生在父类与子类之间,而重载可以发生在同一个类中

B.

覆盖方法可以不同名,而重载方法必须同名

C.

final修饰的方法可以被覆盖,但不能被重载

D.

覆盖与重载是同一回事

 
答案正确:1 分

2-9
分数 1
作者 马俊
单位 兰州大学

有以下Java程序,请问最后的t.printValue(10)会调用哪一个方法?(选择注释中编号)

class Person {
    public void printValue(int i, int j) { }  //1
    public void printValue(int i){ }      //2
}
public class Teacher extends Person {
    public void printValue() { }      //3
    public void printValue(int i) {}   //4
    public static void main(String args[]){
        Person t = new Teacher();
        t.printValue(10);
    }
}
A.

1

B.

2

C.

3

D.

4

 
答案正确:1 分

2-10
分数 1
作者 吴光生
单位 新余学院

Java语言中,类Student是类Person的子类,Student的构造方法中有一句:super(c),该语句意思是( )。

A.

调用类Student中定义的super()方法

B.

调用类Person中定义的super()方法

C.

调用类Person的构造方法

D.

语法错误

 
答案正确:1 分

2-11
分数 1
作者 吕行军
单位 河北农业大学

Java中,关于接口描述错误的是。

A.

接口不能直接new实例化对象

B.

接口中所有的方法都是抽象方法

C.

接口的子类必须重写接口中所有的方法

D.

接口也是一种特殊的类

 
答案错误:0 分

2-12
分数 1
作者 马俊
单位 兰州大学

Java中以下关于protected的说法中,正确的是?

A.

protected修饰的方法,只能给子类使用

B.

protected修饰的类,类中的所有方法只能给子类使用

C.

如果一个类的成员被protected修饰,那么这个成员既能被同一包下的其它类访问,也能被不同包
下该类的子类访问

D.

以上都不对

 
答案正确:1 分

2-13
分数 1
作者 马俊
单位 兰州大学

在Java中,下列关于对象的类型转换的描述,说法错误的是?

A.

对象的类型转换可通过自动转换或强制转换进行

B.

无继承关系的两个类的对象之间试图转换会出现编译错误

C.

由new语句创建的父类对象可以强制转换为子类的对象

D.

子类的对象转换为父类类型后,父类对象不能调用子类的特有方法

 
答案错误:0 分

2-14
分数 1
作者 马俊
单位 兰州大学

在Java中,下列说法正确的是?

A.

JAVA程序的main方法必须写在类里面

B.

一个JAVA类中可以有多个main方法

C.

JAVA程序中类名必须与文件名一样

D.

JAVA程序的main方法中如果只有一条语句,可以不用{}(大括号)括起来

 
答案正确:1 分

2-15
分数 1
作者 马俊
单位 兰州大学

在JAVA中,以下哪个类的对象以键-值的方式存储对象?

A.

java.util.ArrayList

B.

java.util.Stack

C.

java.util.HashMap

D.

java.util.LinkedList

 
答案正确:1 分

2-16
分数 1
作者 马俊
单位 兰州大学

Java中关于this关键字的说法正确的是?

A.

this关键字是在对象内部指代自身的引用

B.

this关键字可以在类中的任何位置使用

C.

this关键字和类关联,而不是和特定的对象关联

D.

同一个类的不同对象共用一个this

 
答案正确:1 分

2-17
分数 1
作者 马俊
单位 兰州大学

在Java语言中,关于this和super关键字说法正确的是?

A.

都可以用在main()方法中

B.

都是指一个内存地址

C.

不能用在main()方法中

D.

意义相同

 
答案正确:1 分

2-18
分数 1
作者 王从银
单位 吉首大学

以下关于构造函数的描述错误的是(    )。

A.

构造函数的返回类型只能是void型。

B.

构造函数是类的一种特殊函数,它的方法名必须与类名相同。

C.

构造函数的主要作用是完成对类的对象的初始化工作。

D.

一般在创建新对象时,系统会自动调用构造函数。

 
答案正确:1 分
 
创建提问
 

2-19
分数 2
作者 王从银
单位 吉首大学

若需要定义一个类属性或类方法,应使用哪种修饰符?(      )

A.

static

B.

package

C.

private

D.

public

 
答案正确:2 分
 
创建提问
 

2-20
分数 2
作者 王从银
单位 吉首大学

假设类A有如下定义,且a是A类的一个实例,则必定错误的选项是(  )。

class  A {
      int  i;
      static  String  s;
       void  method1() {   }
       static  void  method2()  {   }
}
A.

System.out.println(a.i);

B.

a.method1();

C.

A.method1();

D.

A.method2() ;

 
答案错误:0 分
 
创建提问
 

2-21
分数 2
作者 王从银
单位 吉首大学

选项中哪一行代码可以替换题目中//add code here而不产生编译错误?(    )

public abstract class MyClass {
            public int constInt = 5;
          //add code here
           public void method() {                }
}
A.

public abstract void method(int a);

B.

value = value + 5;

C.

public int method();

D.

public abstract void anotherMethod() {}

 
答案正确:2 分
 
创建提问
 

2-22
分数 1
作者 王从银
单位 吉首大学

定义字符串:String s1="hello";对下面程序描述正确的是()。

if(s1=="hello"){
      System.out.println("s1 = "hello"");
}else{
      System.out.println("s1 !=hello");
}
A.

输出 s1 !=hello

B.

编译正确,运行错误

C.

产生编译错误

D.

输出 s1="hello"

 
答案正确:1 分
 
创建提问
 

2-23
分数 2
作者 强彦
单位 太原理工大学

对于类与对象的关系,以下说法错误的是( )。

A.

类是对象的类型

B.

对象由类来创建

C.

类是同类对象的抽象

D.

对象是创建类的模板

 
答案正确:2 分
 
创建提问
 

2-24
分数 2
作者 张德慧
单位 西安邮电大学

Java程序默认引用的包是( )。

A.

java.text包

B.

java.awt包

C.

java.lang包

D.

java.util包

 
答案正确:2 分

2-25
分数 3
作者 信息学院
单位 浙江大学

有一个类A,以下为其构造方法的声明,其中正确的是()。

A.

void A(int x){...}

B.

A(int x){...}

C.

a(int x){...}

D.

void a(int x){...}

 
答案正确:3 分

2-26
分数 2
作者 仇丽青
单位 山东科技大学

访问修饰符作用范围由大到小是( )

A.

private-default-protected-public

B.

public-default-protected-private

C.

private-protected-default-public

D.

public-protected-default-private

 
答案错误:0 分

2-27
分数 2
作者 殷伟凤
单位 浙江传媒学院

在Java中,负责对不再使用的对象自动回收的是( )

A.

垃圾回收器

B.

虚拟机

C.

编译器

D.

多线程机制

 
答案正确:2 分

2-28
分数 2
作者 殷伟凤
单位 浙江传媒学院

对于构造方法,下列叙述不正确的是( )。

A.

构造方法是类的一种特殊方法,它的方法名必须与类名相同

B.

构造方法的返回类型只能是void型,即在方法名前加void

C.

构造方法的主要作用是完成对类的对象的初始化工作

D.

一般在创建新对象时,系统会自动调用构造方法

 
答案正确:2 分

2-29
分数 1
作者 刘永福
单位 河北农业大学

关于Java语言的描述,错误的是()。

A.

每一个.java文件编译后对应一个.class文件。

B.

.java文件编译后,每一个class对应一个.class文件

C.

Java源代码编译后产生的.class是字节码文件

D.

.class文件在JVM上运行

 
答案错误:0 分
 
7-1 立体图形问题
分数 10
作者 段喜龙
单位 南昌航空大学

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

类结构如下图所示(参考):

image.png
试编程完成如上类设计,主方法源码如下(可直接拷贝使用):

 
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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.Scanner;

abstract class Solid {
    public abstract double getSurfaceArea();
    public abstract double getVolume();
}

class Cube extends Solid {
    private double side;

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

    public double getSurfaceArea() {
        return 6 * side * side;
    }

    public double getVolume() {
        return side * side * side;
    }
}
class RegularPyramid extends Solid {
    private double side;

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

    public double getSurfaceArea() {
        return (Math.sqrt(3) / 4) * Math.pow(side, 2) + 3 * (side *  Math.sqrt(Math.pow(side, 2) - Math.pow(side / 2, 2))) / 2;
    }

    public double getVolume() {
        return (Math.pow(side, 3) * Math.sqrt(2)) / 12;
    }
}

public class Main {
    public static void display(Solid solid) {
        String surfaceArea = String.format("%.2f", solid.getSurfaceArea());
        String volume = String.format("%.2f", solid.getVolume());
        System.out.println(surfaceArea);
        System.out.println(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
作者 段喜龙
单位 南昌航空大学

问题描述:本问题中的魔方有两种,一种是正方体魔方,一种是正三棱锥魔方,其中,正方体或正三棱锥魔方是由单元正方体或正三棱锥组成,单元正方体或正三棱锥的个数由阶数(即层数)决定,

即魔方边长=阶数*单元边长。魔方如下图所示:

image.png


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

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

image.png

主方法部分可参考如下源码(可拷贝直接使用):


 
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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.Scanner;
abstract class Solid {
    abstract double getSurfaceArea(); // 计算表面积
    abstract double getVolume(); // 计算体积
}
class Cube extends Solid {
    private double side;
    Cube(double side) {
        this.side = side;
    }
    double getSurfaceArea() {
        return 6 * side * side;
    }
    double getVolume() {
        return side * side * side;
    }
}
class RegularPyramid extends Solid {
    private double side;
    RegularPyramid(double side) {
        this.side = side;
    }
    double getSurfaceArea() {
        return (Math.sqrt(3) / 4) * Math.pow(side, 2) + 3 * (side *  Math.sqrt(Math.pow(side, 2) - Math.pow(side / 2, 2))) / 2;

    }

    double getVolume() {
        return (Math.pow(side, 3) * Math.sqrt(2)) / 12;

    }
}
abstract class RubikCube {
    protected String color;
    protected int layer;
    protected Solid unitSolid;

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

    abstract void displayInfo();
}

class SquareCube extends RubikCube {

    SquareCube(String color, int layer, Cube unitCube) {
        super(color, layer, unitCube);
    }

    void displayInfo() {
        System.out.println(color);
        System.out.printf("%.2f\n", unitSolid.getSurfaceArea() * layer * layer); // 计算表面积
        System.out.printf("%.2f\n", unitSolid.getVolume() * layer * layer * layer); // 计算体积
    }
}
class RegularPyramidCube extends RubikCube {

    RegularPyramidCube(String color, int layer, RegularPyramid unitRegularPyramid) {
        super(color, layer, unitRegularPyramid);
    }
    void displayInfo() {
        System.out.println(color);
        System.out.printf("%.2f\n", unitSolid.getSurfaceArea() * layer * layer); // 计算表面积
        System.out.printf("%.2f\n", unitSolid.getVolume() * layer * layer * layer); // 计算体积
    }
}

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String color1 = input.next();
        int layer1 = input.nextInt();
        double side1 = input.nextDouble();

        RubikCube cube1 = new SquareCube(color1, layer1, new Cube(side1));

        String color2 = input.next();
        int layer2 = input.nextInt();
        double side2 = input.nextDouble();

        RubikCube cube2 = new RegularPyramidCube(color2, layer2, new RegularPyramid(side2));

        display(cube1);
        display(cube2);
    }

    public static void display(RubikCube cube) {
        cube.displayInfo();
    }
}
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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        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 (RubikCube rubikCube : list) {
            System.out.print(rubikCube.getColor() + " " +
                    String.format("%.2f", rubikCube.getSurfaceArea()) + " " +
                    String.format("%.2f", rubikCube.getVolume()));
            System.out.println("");
        }
    }
}

abstract class RubikCube implements Comparable<RubikCube> {
    protected String color;
    protected int layer;

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

    abstract double getSurfaceArea();

    abstract double getVolume();

    public String getColor() {
        return color;
    }
    public int compareTo(RubikCube other) {
        return Double.compare(this.getVolume(), other.getVolume());
    }
}


class RegularPyramid {
    private double side;

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

    public double getSide() {
        return side;
    }
}

class Cube {
    private double side;

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

    public double getSide() {
        return side;
    }
}

class SquareCube extends RubikCube {
    private Cube unitCube;

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

    double getSurfaceArea() {
        return  layer * layer * unitCube.getSide() * unitCube.getSide();
    }

    double getVolume() {
        return Math.pow(layer * unitCube.getSide(), 3);
    }
}


class RegularPyramidCube extends RubikCube {
    private RegularPyramid unitPyramid;

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

    
    double getSurfaceArea() {
         double baseArea = (Math.sqrt(3) / 4) * Math.pow(unitPyramid.getSide(), 2);
        double slantHeight = Math.sqrt(Math.pow(unitPyramid.getSide(), 2) - Math.pow(unitPyramid.getSide() / 2, 2));
        double lateralArea = 3 * (unitPyramid.getSide() * slantHeight) / 2;
        return layer *layer *(baseArea + lateralArea);
    }

    double getVolume() {
        return (Math.pow(unitPyramid.getSide(), 3) * Math.sqrt(2)) / 12*layer *layer * layer;
    }
}

 

7-4 销售步枪问题(附加题)
分数 10
作者 段喜龙
单位 南昌航空大学

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

根据每个月的销售情况,计算销售商的佣金(提成)算法如下:

  • 不到(含)1000美元的部分为10%;

  • 1000(含)~1800美元的部分为15%;

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

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

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

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

image.png

输入格式:

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

输出格式:

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

输入样例1:

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

30 40 50

输出样例1:

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

3800.00 620.00

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

88 56 98

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

Wrong Format
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.Scanner;

class Order {
    private int gun;
    private int stock;
    private int b;

    public Order(int gun, int stock, int b) {
        this.gun = gun;
        this.stock = stock;
        this.b = b;
    }

    public double getTotal() {
        return gun * 45.00 + stock * 30.00 + b * 25.00;
    }

    public double getCommission() {
        double total = getTotal();
        double commission = 0.0;

        if (total <= 1000.00) {
            commission = total * 0.1;
        } else if (total <= 1800.00) {
            commission = 1000.00 * 0.1 + (total - 1000.00) * 0.15;
        } else {
            commission = 1000.00 * 0.1 + 800.00 * 0.15 + (total - 1800.00) * 0.2;
        }

        return commission;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int gun = input.nextInt();
        int stock = input.nextInt();
        int b = input.nextInt();
        if (gun < 0 || gun > 70|| stock < 0 || stock > 80 || b < 0 || b > 90) 
        {
            System.out.println("Wrong Format");
            return;
        }
        Order order = new Order(gun, stock, b);
        System.out.printf("%.2f %.2f", order.getTotal(), order.getCommission());
    }
}

 

3.采坑心得:主要还是对题目看着很复杂,所以有点不是很自信,容易被绕晕。在运用SimpleDateFormat类时不是很懂,在这个地方花费了许多的时间来处理这个点。再则就是,输入时的正则表达式总有情况没有考虑进去,

                      总是在这个点上拿不了全分。

4.改进建议:在课程成绩统计程序中有些测试点能否进一步明确说明一下,最好是能显示在运行测试点后输出的结果,这样可以更好的便于我们进行修改,否则就显示一个答案错误有时候真的找不到是哪里的问题。

5.总结:这三次的题目让我大大提高了对对象的处理,在做题过程中通过csdn学会了很多函数的用法,巩固的字符串方面的知识,更重要的是培养了自己的独立思考能力,思维能力和自学能力。

              这几次作业的难题让我认识到java的对象的学习还有很多是我该去努力学习的,除了听老师讲课,自己课下还应该画更多的时间去接收知识,这样才可以更好的提高自己的编程能力间长一点。