(1)前言
1.第一次题目集知识点主要涉及类的设计和实现、构造方法的使用、成员变量和访问器/修改器的定义、方法的重写（toString方法）、对象的创建和调用方法、控制台输入和输出的使用、浮点数的格式化输出等，题量比较适中，难度也比较适中，要求实现的功能较为基础，但需要一定的类设计和方法实现能力。特别是在理解构造方法和toString方法的使用上可能需要一些思考。题目集01可以帮助我们巩固对类的理解，以及构造方法和方法的实现。同时通过画UML图的要求，可以培养良好的设计习惯。最后一题中等难度，涉及到类的组合，需要理解如何在一个类中使用另一个类的实例作为属性。
2.第二次题目集知识点主要涉及类的设计与实现、接口实现、集合操作、构造方法与初始化、封装与访问控制、输入输出、数据类型和变量等，这一次的训练集主要考察了我们对 Java 编程语言基础知识的掌握程度，题目数量较少，题目中等难度，需要我们对类的设计与实现、构造方法、封装与访问控制、方法设计与实现等方面有一定的编程基础，需要理解如何在方法中修改对象的属性值，要求按照指定格式输入和输出信息，考验对输入输出的处理能力但同时也需要注意细节和代码的书写规范。
3.第三次题目集知识点主要涉及类和对象、封装和构造方法、输入输出、逻辑判定、信息处理、字符串操作、数据结构设计等，本次题目集的题目涉及创建 Student 类、编写 Main 主类、使用 Scanner 进行输入，日期的合法性判断、闰年判定、日期的计算以及输入输出处理等部分，总体来说，本次题目集对于我们来说是一个综合性的练习，涵盖了信息处理、字符串操作、逻辑判断、数据结构设计等多个方面的知识和技能。题量适中，不算太多，但需要考虑到各种异常情况的处理，难度适中。
(2)设计与分析
题目集一 7-1
7-1 设计一个风扇Fan类
分数 4
入门
作者 殷伟凤
单位 浙江传媒学院
设计一个名为Fan的类表示一个风扇。这个类包括：
1.三个名为SlOW、MEDIUM和FAST，其值为1、2和3常量表示风扇的速度。
2.一个名为speed的int类型私有数据域表示风扇的速度（默认值为SLOW）。
3.一个名为on的boolean类型私有数据域表示风扇是否打开（默认值为false）。
4.一个名为radius的double类型私有数据域表示风扇的半径（默认值为5）。
5.一个名为color的string类型数据域表示风扇的颜色（默认值为white）。
6.这四个成员变量(数据域)的访问器和修改器。
7.一个无参构造方法;
8.一个有参构造方法 public Fan(int fanSpeed,boolean fanOn,double fanRadius,String fanColor) { ... }，
9.一个名为toString()的方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就会返回一个由"fan is off"和风扇颜色以及半径组合成的字符串。
请在自己的草稿本上画出UML图，养成良好的设计习惯。
要求：创建两个Fan对象：
第一个对象利用无参构造方法构造默认风扇对象Fan1；
第二个对象依据输入的风扇属性，调用有参构造方法构造自定义风扇对象Fan2。
通过调用它们的toString方法显示这些对象。
输入格式:
第二个对象的属性
输出格式:
分别输出默认风扇和自定义风扇的速度、颜色、半径以及风扇是否打开
输入样例:
在这里给出一组输入。例如：
2
True
6
Red
输出样例:
在这里给出相应的输出。例如：
Default
speed 1
color white
radius 5.0
fan is off
My Fan
speed 2
color Red
radius 6.0
fan is on
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Fan f1 = new Fan();
System.out.println("-------");
System.out.println("Default");
System.out.println("-------");
System.out.println(f1);
int speed = sc.nextInt();
boolean on = "True".equals(sc.next());
double radius = sc.nextDouble();
String color = sc.next();
Fan f2 = new Fan(speed,on,radius,color);
System.out.println("-------");
System.out.println("My Fan");
System.out.println("-------");
System.out.println(f2);
}
}
class Fan{
private final int SLOW = 1;
private final int MEDIUM = 2;
private final int FAST = 3;
private int speed = SLOW;
private boolean on = false;
private double radius = 5;
private String color = "white";
public Fan(int speed, boolean on, double radius, String color) {
this.speed = speed;
this.on = on;
this.radius = radius;
this.color = color;
}
public Fan() {
}
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public boolean isOn() {
return on;
}
public void setOn(boolean on) {
this.on = on;
}
public String toString() {
if(on){
return "speed "+speed+"\ncolor "+color+"\nradius "+radius+"\nfan is on";
}else{
return "speed "+speed+"\ncolor "+color+"\nradius "+radius+"\nfan is off";
}
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
分析：需要定义一个名为Fan的类，包括私有数据域和对应的访问器和修改器，构造方法和toString方法，创建两个Fan对象，一个使用无参构造方法，一个使用有参构造方法，调用这两个对象的toString方法来显示它们的属性。
题目集一 7-2
7-2 类和对象的使用
分数 6
简单
作者 向北
单位 丽江文化旅游学院
1.创建一个类Student,具体属性和方法如下：
属性：（全部私有,数据类型自己选择使用）
姓名（name）,性别(sex)，学号（studentID），年龄(age)，专业（major）
方法：
（1）定义一个空参数构造器public Student();
（2）定义一个多参数的构造器，用于为所有属性赋值public Student(String name,String sex,String studentID,int age,String major)
（3）由于所有属性私有的，为所有属性提供getter（）和setter（）方法；
（4）public String toString()用于返回学生的所有属性信息；
（5）public void printInfo()用于打印学生的信息
2.定义一个测试类Test，在main方法中创建一个Student对象，根据提示输入学生信息保存在对象中，调用printInfo()方法输出学生信息。
3.输出结果参考“输出样例”
输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
姓名：Tom，性别：23，学号：20221201234,年龄：23,专业：计算机科学
输入样例:
在这里给出一组输入。例如：
张三
男
23
计算机科学
2022120
输出样例:
在这里给出相应的输出。例如：
姓名：张三，性别：男，学号：2022120,年龄：23,专业：计算机科学
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Scanner;
class Student {
private String name;
private String sex;
private String studentID;
private int age;
private String major;
public Student() {
}
public Student(String name, String sex, int age, String major, String studentID) {
this.name = name;
this.sex = sex;
this.studentID = studentID;
this.age = age;
this.major = major;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return this.sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getStudentID() {
return this.studentID;
}
public void setStudentID(String studentID) {
this.studentID = studentID;
}
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
public String getMajor() {
return this.major;
}
public void setMajor(String major) {
this.major = major;
}
public String toString() {
return "姓名：" + name + "，性别：" + sex + "，学号：" + studentID + ",年龄：" + age + ",专业：" + major;
}
public void printInfo() {
System.out.println(toString());
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String stuName = input.nextLine();
String stuSex = input.nextLine();
int stuAge = input.nextInt();
input.nextLine();
String stuMajor = input.nextLine();
String stuID = input.nextLine();
Student student = new Student(stuName, stuSex, stuAge, stuMajor, stuID);
student.printInfo();
}
}
分析：需要定义一个名为Student的类，包括私有数据域和对应的访问器和修改器，构造方法和toString方法，以及一个打印信息的方法，需要创建一个Test类，在其中编写main方法，实例化Student对象，调用其方法进行测试。
题目集一 7-3
7-3 成绩计算-1-类、数组的基本运用
分数 8
简单
作者 蔡轲
单位 南昌航空大学
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Scanner;
class Student {
private String studentID;
private String name;
private int chineseScore;
private int mathScore;
private int physicsScore;
public Student(String studentID, String name, int chineseScore, int mathScore, int physicsScore) {
this.studentID = studentID;
this.name = name;
this.chineseScore = chineseScore;
this.mathScore = mathScore;
this.physicsScore = physicsScore;
}
public int calculateTotalScore() {
return chineseScore + mathScore + physicsScore;
}
public double calculateAverageScore() {
return Math.round((double) calculateTotalScore() / 3 * 100) / 100.0; // 保留两位小数
}
public String toString() {
return studentID + " " + name + " " + calculateTotalScore() + " " + String.format("%.2f", calculateAverageScore());
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 5; i++) {
String line = scanner.nextLine();
String[] info = line.split(" ");
String studentID = info[0];
String name = info[1];
int chineseScore = Integer.parseInt(info[2]);
int mathScore = Integer.parseInt(info[3]);
int physicsScore = Integer.parseInt(info[4]);
Student student = new Student(studentID, name, chineseScore, mathScore, physicsScore);
System.out.println(student.toString());
}
scanner.close();
}
}
分析：需要定义一个名为Student的类，包括私有数据域和对应的方法，需要创建一个程序，在其中从用户处获取输入，将输入的信息封装在学生对象中，调用对象的方法进行计算和输出。
题目集一 7-4
7-4 成绩计算-2-关联类
分数 8
简单
作者 蔡轲
单位 南昌航空大学
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩0.4+期末成绩0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Scanner;
class Grades
{
private int ugrade;
private int fgrade;
public Grades(int ugrade,int fgrade)
{
this.ugrade=ugrade;
this.fgrade=fgrade;
}
public int getugrade()
{
return ugrade;
}
public int getfgrade()
{
return fgrade;
}
public int Tgrades()
{
return (int)(ugrade*0.4+fgrade*0.6);
}
}
class Student
{
private String id;
private String name;
private Grades yuwenscore;
private Grades shuxuescore;
private Grades wuliscore;
public Student(String id,String name)
{
this.id=id;
this.name= name;
}
public String getID()
{
return id;
}
public String getname()
{
return name;
}
public Grades getMathscore()
{
return shuxuescore;
}
public void setMathscore(Grades shuxuescore)
{
this.shuxuescore = shuxuescore;
}
public Grades getPhyscore()
{
return wuliscore;
}
public void setPhyscore(Grades wuliscore)
{
this.wuliscore = wuliscore;
}
public Grades getCnscore()
{
return yuwenscore;
}
public void setCnscore(Grades yuwenscore)
{
this.yuwenscore = yuwenscore;
}
public int getallscore()
{
return yuwenscore.Tgrades()+shuxuescore.Tgrades()+wuliscore.Tgrades();
}
public double getavgscore()
{
double sum=yuwenscore.Tgrades()+shuxuescore.Tgrades()+wuliscore.Tgrades();
return (double)(sum/3);
}
public double getuavgscore()
{
double sum=yuwenscore.getugrade()+shuxuescore.getugrade()+wuliscore.getugrade();
return (double)(sum/3);
}
public double getfavgscore()
{
double sum=yuwenscore.getfgrade()+shuxuescore.getfgrade()+wuliscore.getfgrade();
return (double)(sum/3);
}
}
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
Student[] stu=new Student[3];
Grades[] stu1=new Grades[3];
int count=0;
for(int i=0;i<9;i++)
{
String id= sc.next();
String name = sc.next();
String km = sc.next();
int ugrade= sc.nextInt();
int fgrade =sc.nextInt();
int j=i%3;
if(j==0){
stu[count]=new Student(id,name);
stu[count].setCnscore(new Grades(ugrade,fgrade));
}
if(j==1){
stu[count].setMathscore(new Grades(ugrade,fgrade));
}
if(j==2)
{
stu[count].setPhyscore(new Grades(ugrade,fgrade));
count++;
}
}
for(int j=0;j<3;j++)
{
System.out.println(stu[j].getID()+" "+stu[j].getname()+" " + stu[j].getallscore() + " " + String.format("%.2f %.2f %.2f", stu[j].getuavgscore(),stu[j].getfavgscore(),stu[j].getavgscore()));
}
}
}
分析：需要定义两个类：一个是成绩类，一个是学生类，其中学生类中的语文、数学、物理成绩属性类型为成绩类，需要创建一个程序，在其中从用户处获取输入，将输入的信息封装在学生对象中，调用对象的方法进行计算和输出。
题目集一 7-5
7-5 答题判题程序-1
分数 74
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、题目内容
一行为一道题，可以输入多行数据。
格式："#N:"+题号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
3、答题信息
答题信息按行输入，每一行为一组答案，每组答案包含第2部分所有题目的解题答案，答案的顺序号与题目题号相对应。
格式："#A:"+答案内容
格式约束：答案数量与第2部分题目的数量相同，答案之间以英文空格分隔。
样例：#A:2 #A:78
2是题号为1的题目的答案
78是题号为2的题目的答案
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、题目数量
格式：整数数值，若超过1位最高位不能为0，
样例：34
2、答题信息
一行为一道题的答题信息，根据题目的数量输出多行数据。
格式：题目内容+" ~"+答案
样例：1+1=~2
2+2= ~4
3、判题信息
判题信息为一行数据，一条答题记录每个答案的判断结果，答案的先后顺序与题目题号相对应。
格式：判题结果+" "+判题结果
格式约束：
1、判题结果输出只能是true或者false，
2、判题信息的顺序与输入答题信息中的顺序相同
样例：true false true
输入样例1:
单个题目。例如：
1
N:1 #Q:1+1= #A:2
A:2
end
输出样例1:
在这里给出相应的输出。例如：
1+1=~2
true
输入样例2:
单个题目。例如：
1
N:1 #Q:1+1= #A:2
A:4
end
输出样例2:
在这里给出相应的输出。例如：
1+1=~4
false
输入样例3:
多个题目。例如：
2
N:1 #Q:1+1= #A:2
N:2 #Q:2+2= #A:4
A:2 #A:4
end
输出样例3:
在这里给出相应的输出。例如：
1+1=~2
2+2=~4
true true
输入样例4:
多个题目。例如：
2
N:1 #Q:1+1= #A:2
N:2 #Q:2+2= #A:4
A:2 #A:2
end
输出样例4:
在这里给出相应的输出。例如：
1+1=~2
2+2=~2
true false
输入样例5:
多个题目，题号顺序与输入顺序不同。例如：
N:2 #Q:1+1= #A:2
N:1 #Q:5+5= #A:10
A:10 #A:2
end
输出样例5:
在这里给出相应的输出。例如：
5+5=~10
1+1=~2
true true
输入样例6:
含多余的空格符。例如：
1
N:1 #Q: The starting point of the Long March is #A:ruijin
A:ruijin
end
输出样例6:
在这里给出相应的输出。例如：
The starting point of the Long March is~ruijin
true
输入样例7:
含多余的空格符。例如：
1
N: 1 #Q: 5 +5= #A:10
A:10
end
输出样例7:
在这里给出相应的输出。例如：
5 +5=~10
true
设计建议:
以下是针对以上题目要求的设计建议，其中的属性、方法为最小集，实现代码中可根据情况添加所需的内容：
题目类（用于封装单个题目的信息）：
属性：题目编号、题目内容、标准答案-standardAnswer
方法：数据读写set\get方法、
判题方法(答案-answer）：判断答案-answer是否符合标准答案-standardAnswer
试卷类（用于封装整套题目的信息）
属性：题目列表(题目类的对象集合)、题目数量
方法：判题方法(题号-num、答案-answer）：判断答案-answer是否符合对应题号的题目标准答案-standardAnswer
保存题目(题号-num、题目-question）：将题目保存到题目列表中，保存位置与num要能对应
答卷类（用于封装答题信息）
属性：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）
方法：判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.ArrayList;
import java.util.Scanner;
class Question {
private int number;
private String content;
private String standardAnswer;
public Question(int number, String content, String standardAnswer) {
this.number = number;
this.content = content;
this.standardAnswer = standardAnswer;
}
public boolean checkAnswer(String answer) {
return answer.equals(standardAnswer);
}
public String getFormattedQuestion() {
return number + ". " + content;
}
}
class TestPaper {
private ArrayList<Question> questions = new ArrayList<>();
public void addQuestion(int number, String content, String standardAnswer) {
questions.add(new Question(number, content, standardAnswer));
}
public Question getQuestion(int number) {
return questions.get(number - 1);
}
public int getQuestionCount() {
return questions.size();
}
}
class AnswerSheet {
private TestPaper testPaper;
private ArrayList<String> answers = new ArrayList<>();
private ArrayList<Boolean> results = new ArrayList<>();
public AnswerSheet(TestPaper testPaper) {
this.testPaper = testPaper;
}
public void addAnswer(String answer) {
answers.add(answer);
}
public void grade() {
for (int i = 0; i < answers.size(); i++) {
Question question = testPaper.getQuestion(i + 1);
boolean result = question.checkAnswer(answers.get(i));
results.add(result);
}
}
public String getFormattedResults() {
StringBuilder sb = new StringBuilder();
for (boolean result : results) {
sb.append(result ? "1 " : "0 ");
}
return sb.toString().trim();
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int questionCount = Integer.parseInt(scanner.nextLine());
TestPaper testPaper = new TestPaper();
for (int i = 0; i < questionCount; i++) {
String[] input = scanner.nextLine().split(" ");
int number = Integer.parseInt(input[1]);
String content = input[2];
String standardAnswer = input[3];
testPaper.addQuestion(number, content, standardAnswer);
}
AnswerSheet answerSheet = new AnswerSheet(testPaper);
while (true) {
String answerInput = scanner.nextLine();
if (answerInput.equals("end")) {
break;
}
String answer = answerInput.split(":")[1].trim();
answerSheet.addAnswer(answer);
}
answerSheet.grade();
for (int i = 1; i <= testPaper.getQuestionCount(); i++) {
Question question = testPaper.getQuestion(i);
System.out.println(question.getFormattedQuestion());
}
System.out.println(answerSheet.getFormattedResults());
}
}
分析：需要三部分输入：题目数量、题目内容、答题信息，需要了解如何从用户处获取输入，并按照一定格式解析和输出信息，使用适当的数据结构来存储题目信息和答题信息，以便后续比较和输出，对输入的字符串进行适当的分割和处理，以提取出题目编号、内容和标准答案，编写判题逻辑，对用户的答题信息与标准答案进行比较，得出每道题目的判题结果，需要使用循环结构来处理多道题目的输入和判题，需要理解并实现题目内容的解析和判题逻辑，考验对字符串处理和逻辑判断的能力。
题目集二 7-1
7-1 手机按价格排序、查找
分数 10
入门
作者 吴光生
单位 新余学院
编写手机类（MobilePhone），含有type（型号，String类型）、price（价格，int类型）属性，要求该类实现Comparable接口，重写compareTo方法，实现按照price的大小来确定两个手机对象的大小关系。
在链表中添加三个手机对象（从键盘输入），通过Collections类的sort方法对链表中的对象按照price升序排序。输入第四个手机对象的信息，并查找它的price是否与链表中某个对象的price相同。
输入格式:
先输入三部手机的型号、价格信息
再输入要查找的第四部手机的型号、价格信息
每部手机信息的格式如：Redmi9A 599
输出格式:
先输出三部手机排序前的信息
再输出三部手机排序后的信息
最后输出第四部手机是否与前面某部手机价格相同
具体格式参考输出样例
输入样例1:
在这里给出一组输入，第四部手机与前三部中某一部价格相同。例如：
HONOR70 2699
MI12 3499
VIVOS15 3299
RedmiK50 2699
输出样例1:
在这里给出相应的输出，第四部手机与前三部中某一部价格相同。例如：
排序前，链表中的数据：
型号：HONOR70，价格：2699
型号：MI12，价格：3499
型号：VIVOS15，价格：3299
排序后，链表中的数据：
型号：HONOR70，价格：2699
型号：VIVOS15，价格：3299
型号：MI12，价格：3499
RedmiK50与链表中的HONOR70价格相同
输入样例2:
在这里给出一组输入，第四部手机与前面三部的价格都不同。例如：
RedmiNote9 1349
HonorX30 1699
VIVOT2X 1599
OPPOk10 2199
输出样例2:
在这里给出相应的输出，第四部手机与前面三部的价格都不同。例如：
排序前，链表中的数据：
型号：RedmiNote9，价格：1349
型号：HonorX30，价格：1699
型号：VIVOT2X，价格：1599
排序后，链表中的数据：
型号：RedmiNote9，价格：1349
型号：VIVOT2X，价格：1599
型号：HonorX30，价格：1699
链表中的对象，没有一个与OPPOk10价格相同的
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Collections;
import java.util.LinkedList;
import java.util.Scanner;
class MobilePhone implements Comparable<MobilePhone> {
private String type;
private int price;
public MobilePhone(String type, int price) {
this.type = type;
this.price = price;
}
public String getType() {
return type;
}
public int getPrice() {
return price;
}
@Override
public int compareTo(MobilePhone other) {
return Integer.compare(this.price, other.price);
}
@Override
public String toString() {
return "型号：" + type + "，价格：" + price;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
LinkedList<MobilePhone> phoneList = new LinkedList<>();
for (int i = 0; i < 3; i++) {
String input = scanner.nextLine();
String[] parts = input.split(" ");
String type = parts[0];
int price = Integer.parseInt(parts[1]);
phoneList.add(new MobilePhone(type, price));
}
System.out.println("排序前，链表中的数据：");
for (MobilePhone phone : phoneList) {
System.out.println(phone);
}
Collections.sort(phoneList);
System.out.println("排序后，链表中的数据：");
for (MobilePhone phone : phoneList) {
System.out.println(phone);
}
String input = scanner.nextLine();
String[] parts = input.split(" ");
String type = parts[0];
int price = Integer.parseInt(parts[1]);
MobilePhone fourthPhone = new MobilePhone(type, price);
boolean found = false;
for (MobilePhone phone : phoneList) {
if (phone.getPrice() == fourthPhone.getPrice()) {
found = true;
System.out.println(fourthPhone.getType() + "与链表中的" + phone.getType() + "价格相同");
break;
}
}
if (!found) {
System.out.println("链表中的对象，没有一个与" + fourthPhone.getType() + "价格相同的");
}
}
}
分析：需要设计一个手机类（MobilePhone），包括型号（type）和价格（price）属性，并实现Comparable接口以进行比较，实现Comparable接口，重写compareTo方法，按照价格比较两个手机对象的大小关系，使用链表（LinkedList）存储手机对象，并利用Collections类的sort方法对链表中的对象按照价格升序排序， 从键盘输入手机对象信息，并按照指定格式解析和输出信息， 查找第四部手机的价格是否与链表中某个对象的价格相同。
题目集二 7-2
7-2 sdut-oop-4-求圆的面积（类与对象）
分数 10
入门
作者 周雪芹
单位 山东理工大学
按要求完成程序的编写。
1、定义圆类Circle，其中包括：
（1）成员变量：private int radius
（2）无参构造方法 ，给radius赋值为2，并输出信息："This is a constructor with no para."；
（2）有参构造方法 ，接收用户给的radius赋值，并输出"This is a constructor with para."（如果给的半径小于等于0,则赋默认值为2）；
（3）为radius添加set方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2；
（4）为radius半径添加get方法，返回用户输入的半径；
（5）求圆面积方法getArea(), π使用Math.PI代替；
（6）定义toString方法，public String toString( )方法体为：
return "Circle [radius=" + radius + "]";
2、定义Main类，在main方法中，完成下列操作：
（1）定义并创建Circle类对象c1，输出c1对象，求c1的面积并输出；
（2）定义并创建Circle类对象c2，输出c2对象，求c2的面积并输出；
（3）从键盘接收整数半径，赋值给c2的半径，输出c2对象，求c2的面积并输出；
（4）从键盘接收整数半径，用有参构造方法创建Circle类对象c3，输出c3对象，求c3的面积后输出。
输入格式:
输入有多行。每行包括一个整数的圆的半径。
输出格式:
按照题目要求，输出圆构造方法的输出信息、圆对象的字符中描述信息、及圆的面积（其中圆的面积保留2位小数）。上述信息各占一行。
输入样例:
4
5
输出样例:
This is a constructor with no para.
Circle [radius=2]
12.57
This is a constructor with no para.
Circle [radius=2]
12.57
Circle [radius=4]
50.27
This is a constructor with para.
Circle [radius=5]
78.54
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Scanner;
class Circle {
private int radius;
public Circle() {
radius = 2;
System.out.println("This is a constructor with no para.");
}
public Circle(int radius) {
if (radius <= 0) {
this.radius = 2;
} else {
this.radius = radius;
}
System.out.println("This is a constructor with para.");
}
public void setRadius(int radius) {
if (radius <= 0) {
this.radius = 2;
} else {
this.radius = radius;
}
}
public int getRadius() {
return radius;
}
public double getArea() {
return Math.PI * radius * radius;
}
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Circle c1 = new Circle();
System.out.println(c1);
System.out.printf("%.2f\n", c1.getArea());
Circle c2 = new Circle();
System.out.println(c2);
System.out.printf("%.2f\n", c2.getArea());
int radius = scanner.nextInt();
c2.setRadius(radius);
System.out.println(c2);
System.out.printf("%.2f\n", c2.getArea());
radius = scanner.nextInt();
Circle c3 = new Circle(radius);
System.out.println(c3);
System.out.printf("%.2f\n", c3.getArea());
scanner.close();
}
}
分析：需要设计一个圆类（Circle），包括半径（radius）属性，并实现无参构造方法、有参构造方法、set方法、get方法、求面积方法（getArea）以及toString方法， 包括无参构造方法和有参构造方法，需要考虑半径的合法性， 将半径属性设置为私有，并通过set和get方法进行封装， 从键盘输入整数半径，并输出构造方法的信息、对象描述信息和面积信息，计算圆的面积，使用Math.PI进行π的获取，进行精确计算。
题目集二 7-3
7-3 Java类与对象-汽车类
分数 7
入门
作者 李建华
单位 石家庄铁道大学
设计一个用来描述汽车的类，使用类的非静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度，使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。在下图中的【1】【2】【3】处填入正确代码使程序可以正确输出。
/**
- @author Teacher
-
主类，用来在pta中运行。 -
其中有一处代码需要完善
*/
public class Main {
public static void main(String[] args) {
// 此处填写合适的代码【1】
// 生成汽车实例
System.out.printf("车主:%s,速度:%.1f,角度:%.1f\n", car.getOwnerName(), car.getCurSpeed(), car.getCurDirInDegree());
// 设置新速度
car.changeSpeed(10);
System.out.printf("车主:%s,速度:%.1f,角度:%.1f\n", car.getOwnerName(), car.getCurSpeed(), car.getCurDirInDegree());
// 停车
car.stop();
System.out.printf("车主:%s,速度:%.1f,角度:%.1f\n", car.getOwnerName(), car.getCurSpeed(), car.getCurDirInDegree());
}
}
/**
- @author Teacher
-
汽车类，其中有两个内容需要完善。
*/
class Car {
// 车主姓名
private String ownerName;
// 当前车速
private float curSpeed;
// 当前方向盘转向角度
private float curDirInDegree;
public Car(String ownerName) {
this.ownerName = ownerName;
}
public Car(String ownerName, float speed, float dirInDegree) {
this(ownerName);
this.curSpeed = speed;
this.curDirInDegree = dirInDegree;
}
// 提供对车主姓名的访问
public String getOwnerName() {
return ownerName;
}
// 提供对当前方向盘转向角度的访问
public float getCurDirInDegree() {
return curDirInDegree;
}
// 提供对当前车速的访问
public float getCurSpeed() {
return curSpeed;
}
// 提供改变当前的车速
public void changeSpeed(float curSpeed) {
// 此处填写合适的代码【2】
}
// 提供停车
public void stop() {
// 此处填写合适的代码【3】
}
}
输入格式:
无
输出格式:
车主:bob,速度:0.0,角度:0.0
车主:bob,速度:10.0,角度:0.0
车主:bob,速度:0.0,角度:0.0
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
车主:bob,速度:0.0,角度:0.0
车主:bob,速度:10.0,角度:0.0
车主:bob,速度:0.0,角度:0.0
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
public class Main {
public static void main(String[] args) {
Car car = new Car("bob");
System.out.printf("车主:%s,速度:%.1f,角度:%.1f\n", car.getOwnerName(), car.getCurSpeed(), car.getCurDirInDegree());
car.changeSpeed(10);
System.out.printf("车主:%s,速度:%.1f,角度:%.1f\n", car.getOwnerName(), car.getCurSpeed(), car.getCurDirInDegree());
car.stop();
System.out.printf("车主:%s,速度:%.1f,角度:%.1f\n", car.getOwnerName(), car.getCurSpeed(), car.getCurDirInDegree());
}
}
class Car {
private String ownerName;
private float curSpeed;
private float curDirInDegree;
public Car(String ownerName) {
this.ownerName = ownerName;
}
public Car(String ownerName, float speed, float dirInDegree) {
this(ownerName);
this.curSpeed = speed;
this.curDirInDegree = dirInDegree;
}
public String getOwnerName() {
return ownerName;
}
public float getCurDirInDegree() {
return curDirInDegree;
}
public float getCurSpeed() {
return curSpeed;
}
public void changeSpeed(float newSpeed) {
if (newSpeed >= 0) {
curSpeed = newSpeed;
}
}
public void stop() {
curSpeed = 0;
}
}
分析：需要设计一个汽车类（Car），包括车主姓名（ownerName）、当前车速（curSpeed）和当前方向盘转向角度（curDirInDegree）属性，并实现有参构造方法、get方法和改变速率、停车两个操作的方法，包括有参构造方法，用于初始化车主姓名、当前车速和当前方向盘转向角度， 将属性设置为私有，并通过get方法进行封装看， 在主类中输出汽车信息，包括车主姓名、当前车速和当前方向盘转向角度，包括改变速率（changeSpeed）和停车（stop）两个操作，需要在方法中实现对当前车速的修改。
题目集二 7-4
7-4 答题判题程序-2
分数 73
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-1基础上增补或者修改的内容。
要求输入题目信息、试卷信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三种，三种信息可能会打乱顺序混合输入：
1、题目信息
一行为一道题，可输入多行数据（多道题）。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、试卷信息
一行为一张试卷，可输入多行数据（多张卷）。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2
3、答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。
格式："#S:"+试卷号+" "+"#A:"+答案内容
格式约束：答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
22是1号试卷的顺序第2题的题目答案
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：alert: full score of test paper2 is not 100 points
2、答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+""+答案++""+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
样例：3+2=5true
4+6=~22~false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
设计建议：
参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。
输入样例1:
一张试卷一张答卷。试卷满分不等于100。
例如：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#S:1 #A:5 #A:22
end
输出样例1:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
2+2=22false
0 0~0
输入样例2:
一张试卷一张答卷。试卷满分不等于100。
例如：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#S:1 #A:5 #A:22
end
输出样例2:
在这里给出相应的输出。例如：
1+1=5false
2+2=22false
0 0~0
输入样例3:
一张试卷、一张答卷。各类信息混合输入。
例如：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
1+1=5false
2+2=4true
0 30~30
输入样例4:
试卷题目的顺序与题号不一致。
例如：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 2-70 1-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:22
end
输出样例:
在这里给出相应的输出。例如：
2+2=5false
1+1=22false
0 0~0
输入样例5:
乱序输入。
例如：#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
end
输出样例:
在这里给出相应的输出。例如：
3+2=5true
2+2=22false
70 0~70
输入样例6:
乱序输入+两份答卷。
例如：#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
3+2=5true
2+2=22false
70 0~70
3+2=5true
2+2=4true
70 30~100
输入样例7:
乱序输入+分值不足100+两份答卷。
例如：#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
3+2=5true
2+2=22false
7 0~7
3+2=5true
2+2=4true
7 6~13
输入样例8:
乱序输入+分值不足100+两份答卷+答卷缺失部分答案。
例如：#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#T:2 2-5 1-3 3-2
#S:2 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
3+2=5true
2+2=22false
7 0~7
2+2=5false
1+1=4false
answer is null
0 0 0~0
输入样例9:
乱序输入+分值不足100+两份答卷+无效的试卷号。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-7 2-6
#S:3 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.*;
class Question {
private int number;
private String content;
private String answer;
public Question(int number, String content, String answer) {
this.number = number;
this.content = content;
this.answer = answer;
}
public int getNumber() {
return number;
}
public String getContent() {
return content;
}
public String getAnswer() {
return answer;
}
}
class TestPaper {
private int paperNumber;
private Map<Integer, Integer> questions;
public TestPaper(int paperNumber) {
this.paperNumber = paperNumber;
questions = new HashMap<>();
}
public void addQuestion(int questionNumber, int score) {
questions.put(questionNumber, score);
}
public int getPaperNumber() {
return paperNumber;
}
public Map<Integer, Integer> getQuestions() {
return questions;
}
}
class AnswerSheet {
private int paperNumber;
private List<String> answers;
public AnswerSheet(int paperNumber) {
this.paperNumber = paperNumber;
answers = new ArrayList<>();
}
public void addAnswer(String answer) {
answers.add(answer);
}
public int getPaperNumber() {
return paperNumber;
}
public List<String> getAnswers() {
return answers;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<Question> questions = new ArrayList<>();
List<TestPaper> testPapers = new ArrayList<>();
List<AnswerSheet> answerSheets = new ArrayList<>();
String input;
while (!(input = scanner.nextLine()).equals("end")) {
if (input.startsWith("#N:")) {
String[] parts = input.split(" ");
int number = Integer.parseInt(parts[0].substring(4));
String content = parts[1].substring(3);
String answer = parts[2].substring(3);
questions.add(new Question(number, content, answer));
} else if (input.startsWith("#T:")) {
String[] parts = input.split(" ");
int paperNumber = Integer.parseInt(parts[0].substring(4));
TestPaper testPaper = new TestPaper(paperNumber);
for (int i = 1; i < parts.length; i++) {
String[] pair = parts[i].split("-");
int questionNumber = Integer.parseInt(pair[0]);
int score = Integer.parseInt(pair[1]);
testPaper.addQuestion(questionNumber, score);
}
testPapers.add(testPaper);
} else if (input.startsWith("#S:")) {
String[] parts = input.split(" ");
int paperNumber = Integer.parseInt(parts[0].substring(4));
AnswerSheet answerSheet = new AnswerSheet(paperNumber);
for (int i = 1; i < parts.length; i++) {
answerSheet.addAnswer(parts[i].substring(3));
}
answerSheets.add(answerSheet);
}
}
for (AnswerSheet answerSheet : answerSheets) {
int paperNumber = answerSheet.getPaperNumber();
TestPaper testPaper = findTestPaper(testPapers, paperNumber);
if (testPaper == null) {
System.out.println("The test paper number does not exist");
continue;
}
int totalScore = 0;
Map<Integer, Integer> questionScores = new HashMap<>();
List<String> answers = answerSheet.getAnswers();
for (int i = 0; i < answers.size(); i++) {
String answer = answers.get(i);
int questionNumber = i + 1;
int score = 0;
if (testPaper.getQuestions().containsKey(questionNumber)) {
int questionScore = testPaper.getQuestions().get(questionNumber);
Question question = findQuestion(questions, questionNumber);
if (question != null && question.getAnswer().equals(answer)) {
score = questionScore;
}
}
questionScores.put(questionNumber, score);
totalScore += score;
}
if (totalScore != 100) {
System.out.println("alert: full score of test paper" + paperNumber + " is not 100 points");
}
for (int i = 0; i < answers.size(); i++) {
int questionNumber = i + 1;
String answer = answers.get(i);
int score = questionScores.get(questionNumber);
boolean isCorrect = score > 0;
System.out.println(questionNumber + "~" + answer + "~" + isCorrect);
}
System.out.print(questionScores.values().toString().replaceAll("[\\[\\],]", "") + "~" + totalScore);
}
}
private static TestPaper findTestPaper(List<TestPaper> testPapers, int paperNumber) {
for (TestPaper testPaper : testPapers) {
if (testPaper.getPaperNumber() == paperNumber) {
return testPaper;
}
}
return null;
}
private static Question findQuestion(List<Question> questions, int questionNumber) {
for (Question question : questions) {
if (question.getNumber() == questionNumber) {
return question;
}
}
return null;
}
}
分析：这个java程序相当于一个考试系统，它包括三个主要的类：Question（问题）、TestPaper（试卷）和AnswerSheet（答题卡）。这些类用于表示考试中的问题、试卷和学生的答题情况。程序的主要逻辑是从标准输入读取输入数据，然后进行处理和判断，最后输出结果，整体设计相对清晰，使用了面向对象的思想，将问题、试卷和答题卡等不同的概念分别封装成类，提高了代码的可读性和可维护性。
题目集三 7-1
7-1 面向对象编程(封装性)
分数 6
简单
作者 蒋辉
单位 天津仁爱学院
Student类具体要求如下：
私有成员变量：学号(sid，String类型)，姓名(name，String类型)，年龄(age，int类型)，专业(major，String类型) 。
提供无参构造和有参构造方法。（注意：有参构造方法中需要对年龄大小进行判定）
普通成员方法：print()，输出格式为“学号：6020203100，姓名：王宝强，年龄：21，专业：计算机科学与技术”。
普通成员方法：提供setXxx和getXxx方法。（注意：setAge()方法中需要对年龄进行判定）
注意：
年龄age不大于0，则不进行赋值。
print()中的“：”和“，”为均为中文冒号和逗号。
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
//调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
//对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}
/* 请在这里填写答案 */
输入格式:
无
输出格式:
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程
输入样例:
在这里给出一组输入。例如：
6020203110 王宝强 21 计算机科学与技术
6020203119 张三丰 23 软件工程
输出样例:
在这里给出相应的输出。例如：
学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.Scanner;
class Student {
private String sid;
private String name;
private int age;
private String major;
public Student() {}
public Student(String sid, String name, int age, String major) {
this.sid = sid;
this.name = name;
if (age > 0) {
this.age = age;
} else {
this.age = 0;
}
this.major = major;
}
public void print() {
System.out.println("学号：" + sid + "，姓名：" + name + "，年龄：" + age + "，专业：" + major);
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSid() {
return sid;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
if (age > 0) {
this.age = age;
} else {
this.age = 0;
}
}
public int getAge() {
return age;
}
public void setMajor(String major) {
this.major = major;
}
public String getMajor() {
return major;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
student1.print();
student2.print();
}
}
分析：要求创建一个名为 Student 的类，包含私有成员变量（学号、姓名、年龄、专业）、无参构造方法、有参构造方法以及普通成员方法（print()、setXxx()、getXxx()），强调了使用私有成员变量并通过公有的 setter 和 getter 方法进行访问，以及对年龄进行合理性判定的要求，这体现了封装的思想。另外，要求有参构造方法中对年龄进行判定，保证合理性，在 Main 类中处理输入和输出逻辑，包括使用 Scanner 进行输入，创建对象并调用方法输出学生信息。
题目集三 7-2
7-2 jmu-java-日期类的基本使用
分数 10
简单
作者 郑如滨
单位 集美大学
给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。
输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。
输入样例1:
第一行日期非法、第二行有日期非法
2020-02-30
2020-02-30 2020-01-02
输出样例1:
2020-02-30无效!
2020-02-30或2020-01-02中有不合法的日期.
输入样例2:
均有效且合法
2021-02-28
2019-08-01 2020-01-02
输出样例2:
2021-02-28是当年第59天,当月第28天,当周第7天.
2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1.
输入样例3:
日期均有效，但结束日期早于开始日期
2020-02-28
2020-02-02 2020-02-01
输出样例3:
2020-02-28是闰年.
2020-02-28是当年第59天,当月第28天,当周第5天.
2020-02-01早于2020-02-02,不合法!
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
栈限制
8192 KB
代码：
import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.Year;
import java.util.Calendar;
import java.util.Date;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String line = input.nextLine();
String nextLine = input.nextLine();
String[] arr = line.split("-");
int year = Integer.parseInt(arr[0]);
int mouth = Integer.parseInt(arr[1]);
int day = Integer.parseInt(arr[2]);
boolean valid=Main.isValidDate(line,"yyyy-MM-dd");
if ((judge(year,mouth,day)==true)&&valid==true){
Calendar c = Calendar.getInstance();
c.set(year, mouth-1, day);
int weekDay = c.get(Calendar.DAY_OF_WEEK);
int monthDay = c.get(Calendar.DAY_OF_MONTH);
int yearDay = c.get(Calendar.DAY_OF_YEAR);
if (weekDay == 1) {
weekDay = 7;
} else {
weekDay = weekDay - 1;
}
Year firstYear = Year.of(year);
if (firstYear.isLeap()){
System.out.println(line+"是闰年.");
}
System.out.println(line+"是当年第"+yearDay+"天" +",当月第"+monthDay+
"天,当周第"+weekDay+"天.");
}else {
System.out.println(line+"无效!");
}
String[] arr1 = nextLine.split(" ");
boolean valid1=Main.isValidDate(arr1[0],"yyyy-MM-dd");
boolean valid2=Main.isValidDate(arr1[1],"yyyy-MM-dd");
if (valid1==false||valid2==false){
System.out.println(arr1[0]+"或"+arr1[1]+"中有不合法的日期.");
System.exit(0);
}
DateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
try {
Date star = dft.parse(arr1[0]);
String[] st1=arr1[0].split("-");
int t1=Integer.parseInt(st1[1]);
int t11=Integer.parseInt(st1[0]);
String[] st2=arr1[1].split("-");
int t2=Integer.parseInt(st2[1]);
int t22=Integer.parseInt(st2[0]);
Date end = dft.parse(arr1[1]);
int i1=0;
int i2=0;
int i3=0;
if (star.before(end)){
Year firstYear = Year.of(t11);
i3=t22-t11;
Calendar c1 = Calendar.getInstance();
c1.set(t11, t1-1, Integer.parseInt(st1[2]));
int yearDay = c1.get(Calendar.DAY_OF_YEAR);
Calendar c2 = Calendar.getInstance();
c2.set(t22, t2-1, Integer.parseInt(st2[2]));
int yearDa2y = c2.get(Calendar.DAY_OF_YEAR);
if (firstYear.isLeap(t11)){
int temp=yearDa2y+(366-yearDay);
for (int i=t11+1;i<t22;i++){
if (firstYear.isLeap(i)){
i1=i1+366;
}else {
i1=i1+365;
}
}
i1=i1+temp;
}else {
int temp=yearDa2y+(365-yearDay);
for (int i=t11+1;i<t22;i++){
if (firstYear.isLeap(i)){
i1=i1+366;
}else {
i1=i1+365;
}
}
i1=i1+temp;
}
i2=Integer.parseInt(st2[1])-Integer.parseInt(st1[1]);
}
if (end.before(star)){
System.out.println(arr1[1]+"早于"+arr1[0]+",不合法!");
System.exit(0);
}
if ((judge(t11,t1,Integer.parseInt(st1[2]))==true)&&judge(t22,t2,Integer.parseInt(st2[2]))==true){
System.out.println(arr1[1]+"与"+arr1[0]+"之间相差"+i1+"天,"+"所在月份相差"+i2+",所在年份相差"+i3+".");
}else {
System.out.println(arr1[0]+"或"+arr1[1]+"中有不合法的日期.");
}
} catch (ParseException e) {
e.printStackTrace();
}
}
public static boolean isValidDate(String dttm,String format) {
if (dttm == null || dttm.isEmpty() || format == null || format.isEmpty()) {
return false;
}
if (format.replaceAll("'.+?'", "").indexOf("y") < 0) {
format += "/yyyy";
DateFormat formatter = new SimpleDateFormat("/yyyy");
dttm += formatter.format(new Date());
}
String regex = "^\\d{4}\\-(0[1-9]|1[012])\\-(0[1-9]|[12][0-9]|3[01])$";
if (!dttm.matches(regex)){
return false;
}
DateFormat formatter = new SimpleDateFormat(format);
formatter.setLenient(false);
ParsePosition pos = new ParsePosition(0);
Date date = formatter.parse(dttm, pos);
if (date == null || pos.getErrorIndex() > 0) {
return false;
}
if (pos.getIndex() != dttm.length()) {
return false;
}
if (formatter.getCalendar().get(Calendar.YEAR) > 9999) {
return false;
}
return true;
}
public static boolean judge(int y,int sum,int date) {
boolean count=false;
if(sum==1||sum==3||sum==5||sum==7||sum==8||sum==10||sum==12) {
if(date<=31) {
count = true;}
else {
count = false;
}
}
else if(sum<1||sum>12) {
count=false;}
else if(sum==2) {
if(y%400==0||(y%4==0&&y%100!=0)) {
if(date>29) {
count=false;
}
else {
count = true;
}
}
else {
if(date>28) {
count=false;
}
else{
count=true;
}
}
}
else {
if(date>30) {
count = false;
}
else{
count = true;
}
}
return count;
}
}
分析：要求对输入的日期进行合法性判断，包括年份、月份和日期的范围判断，涉及到基本的字符串处理和类型转换， 需要判断给定年份是否为闰年，闰年的判定规则为能被4整除但不能被100整除，或者能被400整除，计算给定日期是当年的第几天、当月的第几天、当周的第几天，这涉及到对日期的解析和计算，处理输入的日期字符串，然后根据计算结果输出相应信息或错误提示。
题目集三 7-3
7-3 答题判题程序-3
分数 84
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-2基础上增补或者修改的内容，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分五种，信息可能会打乱顺序混合输入。
1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。
格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、试卷信息
试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。
格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2
3、学生信息
学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。
格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息
答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。答卷中：
格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号
5、删除题目信息
删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”
格式："#D:N-"+题目号
格式约束：
题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。
本题暂不考虑删除的题号不存在的情况。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出
alert: full score of test paper1 is not 100 points
1+1=5false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。
输出格式:
1、试卷总分警示
该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
样例：alert: full score of test paper2 is not 100 points
2、答卷信息
一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。
格式：题目内容+""+答案++""+判题结果（true/false）
约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
样例：
3+2=5true
4+6=22false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、被删除的题目提示信息
当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。
5、题目引用错误提示信息
试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：
输入：#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-4
end
输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：
输入：#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103
end
输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式错误提示信息
输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。
例如：wrong format:2 #Q:2+2= #4
7、试卷号引用错误提示输出
如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。
8、学号引用错误提示信息
如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。
本题暂不考虑出现多张答卷的信息的情况。
输入样例1:
简单输入，不含删除题目信息。
例如：#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:1 20201103 #A:1-5
end
输出样例1:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
20201103 Tom: 0~0
输入样例2:
简单输入，答卷中含多余题目信息（忽略不计）。
例如：#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:1 20201103 #A:1-2 #A:2-3
end
输出样例3
简单测试，含删除题目信息。例如：
alert: full score of test paper1 is not 100 points
1+1=2true
20201103 Tom: 5~5
输入样例3:
简单测试，含删除题目信息。
例如：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例3:
在这里给出相应的输出，第二题由于被删除，输出题目失效提示。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例4:
简单测试，含试卷无效题目的引用信息以及删除题目信息（由于题目本身无效，忽略）。
例如：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例4:
输出不存在的题目提示信息。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
non-existent question~0
20201103 Tom: 0 0~0
输入样例5:
综合测试，含错误格式输入、有效删除以及无效题目引用信息。
例如：#N:1 +1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
输出样例5:
在这里给出相应的输出。例如：
wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例6:
综合测试，含错误格式输入、有效删除、无效题目引用信息以及答案没有输入的情况。
例如：#N:1 +1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-5
#D:N-2
end
输出样例6:
答案没有输入的优先级最高。例如：
wrong format:#N:1 +1= #A:2
alert: full score of test paper1 is not 100 points
non-existent question~0
answer is null
20201103 Tom: 0 0~0
输入样例7:
综合测试，正常输入，含删除信息。
例如：#N:2 #Q:2+2= #A:4
#N:1 #Q:1+1= #A:2
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:2-4 #A:1-5
#D:N-2
end
输出样例7:
例如：
alert: full score of test paper1 is not 100 points
1+1=5false
the question 2 invalid~0
20201103 Tom: 0 0~0
输入样例8:
综合测试，无效的试卷引用。
例如：#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201103 Tom
#S:2 20201103 #A:1-5 #A:2-4
end
输出样例8:
例如：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
输入样例9:
无效的学号引用。
例如：#N:1 #Q:1+1= #A:2
#T:1 1-5
#X:20201106 Tom
#S:1 20201103 #A:1-5 #A:2-4
end
输出样例9:
答案照常输出，判分时提示错误。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
20201103 not found
输入样例10:
信息可打乱顺序输入：序号不是按大小排列，各类信息交错输入。但本题不考虑引用的题目在被引用的信息之后出现的情况（如试卷引用的所有题目应该在试卷信息之前输入），所有引用的数据应该在被引用的信息之前给出。
例如：#N:3 #Q:中国第一颗原子弹的爆炸时间 #A:1964.10.16
#N:1 #Q:1+1= #A:2
#X:20201103 Tom-20201104 Jack-20201105 Www
#T:1 1-5 3-8
#N:2 #Q:2+2= #A:4
#S:1 20201103 #A:1-5 #A:2-4
end
输出样例10:
答案按试卷中的题目顺序输出。例如：
alert: full score of test paper1 is not 100 points
1+1=5false
中国第一颗原子弹的爆炸时间4false
20201103 Tom: 0 0~0
代码长度限制
30 KB
时间限制
1500 ms
内存限制
64 MB
栈限制
8192 KB
代码如下：
import java.util.*;
class TestPaper {
private int paperNumber;
private Map<Integer, Integer> questions;
public TestPaper(int paperNumber) {
this.paperNumber = paperNumber;
this.questions = new HashMap<>();
}
public void addQuestion(int questionNumber, int score) {
questions.put(questionNumber, score);
}
public int getPaperNumber() {
return paperNumber;
}
public Map<Integer, Integer> getQuestions() {
return questions;
}
}
class Student {
private String id;
private String name;
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
}
class Answer {
private int questionNumber;
private String content;
public Answer(int questionNumber, String content) {
this.questionNumber = questionNumber;
this.content = content;
}
public int getQuestionNumber() {
return questionNumber;
}
public String getContent() {
return content;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<String> inputLines = new ArrayList<>();
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
if (line.equals("end")) {
break;
}
inputLines.add(line);
}
processInput(inputLines);
}
private static void processInput(List<String> inputLines) {
Map<Integer, String> questions = new HashMap<>();
Map<Integer, TestPaper> testPapers = new HashMap<>();
List<Student> students = new ArrayList<>();
List<String> answers = new ArrayList<>();
List<String> deleteCommands = new ArrayList<>();
for (String line : inputLines) {
if (line.startsWith("#N:")) {
String[] parts = line.split(" ");
int questionNumber = Integer.parseInt(parts[1]);
String questionContent = parts[2].substring(4);
questions.put(questionNumber, questionContent);
} else if (line.startsWith("#T:")) {
String[] parts = line.split(" ");
int paperNumber = Integer.parseInt(parts[0].substring(3));
TestPaper testPaper = new TestPaper(paperNumber);
for (int i = 1; i < parts.length; i++) {
String[] questionPart = parts[i].split("-");
int questionNumber = Integer.parseInt(questionPart[0]);
int score = Integer.parseInt(questionPart[1]);
testPaper.addQuestion(questionNumber, score);
}
testPapers.put(paperNumber, testPaper);
} else if (line.startsWith("#X:")) {
String[] parts = line.split(" ");
for (int i = 1; i < parts.length; i++) {
String[] studentPart = parts[i].split("-");
String id = studentPart[0];
String name = studentPart[1];
students.add(new Student(id, name));
}
} else if (line.startsWith("#S:")) {
answers.add(line);
} else if (line.startsWith("#D:")) {
deleteCommands.add(line);
}
}
for (String deleteCommand : deleteCommands) {
int questionNumberToDelete = Integer.parseInt(deleteCommand.substring(4));
questions.remove(questionNumberToDelete);
}
for (String answerLine : answers) {
String[] parts = answerLine.split(" ");
int paperNumber = Integer.parseInt(parts[0].substring(3));
String studentId = parts[1];
Map<Integer, String> answerMap = new HashMap<>();
for (int i = 2; i < parts.length; i++) {
String[] answerPart = parts[i].split("-");
int questionNumber = Integer.parseInt(answerPart[0]);
String answerContent = answerPart[1];
answerMap.put(questionNumber, answerContent);
}
evaluateAnswers(testPapers.get(paperNumber), studentId, answerMap, students, questions);
}
}
private static void evaluateAnswers(TestPaper testPaper, String studentId, Map<Integer, String> answerMap, List<Student> students, Map<Integer, String> questions) {
System.out.println("alert: full score of test paper" + testPaper.getPaperNumber() + " is not 100 points");
boolean studentExists = false;
for (Student student : students) {
if (student.getId().equals(studentId)) {
studentExists = true;
break;
}
}
if (!studentExists) {
System.out.println(studentId + " does not exist");
return;
}
StringBuilder sb = new StringBuilder();
int totalScore = 0;
for (Map.Entry<Integer, Integer> entry : testPaper.getQuestions().entrySet()) {
int questionNumber = entry.getKey();
int score = entry.getValue();
String answer = answerMap.getOrDefault(questionNumber, "");
if (!questions.containsKey(questionNumber)) {
sb.append("non-existent question~0\n");
} else if (answer.isEmpty()) {
sb.append("answer is null\n");
} else {
String correctAnswer = questions.get(questionNumber);
boolean isCorrect = answer.equals(correctAnswer);
if (isCorrect) {
totalScore += score;
}
sb.append(correctAnswer).append("~").append(answer).append("~").append(isCorrect).append("\n");
}
}
System.out.println(sb.toString().trim() + "\n" + studentId + ": " + totalScore + "~" + totalScore);
}
}
分析：首先，程序需要能够正确解析输入信息，这涉及到对输入信息的格式解析和字符串处理的技能。在处理题目信息、试卷信息、学生信息、答卷信息以及删除题目信息时，需要对字符串进行分割、提取关键信息等操作，这需要对字符串操作方法的熟练掌握。其次，程序需要能够进行逻辑判断和条件判断，根据题目信息和答卷信息判断答案的正确性，并输出相应的判题结果。这需要对逻辑运算和条件判断语句的理解和运用。此外，程序还需要设计合适的数据结构来存储题目信息、试卷信息、学生信息等，以便于后续的处理和操作。对于存储和组织数据的能力是很重要的，这也涉及到数据结构的选择和设计。在处理异常情况时，程序需要能够正确地进行错误处理，例如处理格式错误、输入信息缺失等情况。这需要对异常处理机制的了解和运用，以保证程序的稳定性和健壮性。总体来说，这个题目对于我们来说是一个综合性的练习，涵盖了信息处理、字符串操作、逻辑判断、数据结构设计等多个方面的知识和技能。通过解决这个题目，我们能够提升自己的编程能力和综合应用能力。
(3)采坑心得
1、对于题目集一的7-4，在计算总成绩时，需要注意保留整数部分，可以使用强制类型转换或者Math.floor()方法，在计算总成绩时，需要注意保留整数部分，可以使用强制类型转换或者Math.floor()方法，需要正确解析输入的学生信息，并根据课程名将成绩信息封装到对应的成绩类对象中。
2、对于题目集二的7-1，需要注意以下几个方面的内容，实现Comparable接口：确保类可以进行比较，并按照price属性的大小确定大小关系，重写compareTo方法：在该方法中定义两个手机对象的比较规则，按照价格升序排列，查找第四部手机的价格是否与链表中某个对象的价格相同。
3、对于题目集二的7-2，对于有参构造方法，要注意判断用户输入的半径是否小于等于0，以决定是否使用默认值，在求圆的面积时，要注意使用Math.PI常量，在set方法中，要对用户输入的半径进行合理性检查，并作出相应处理。
4、对于题目集三的7-1，特别要注意对于有参构造方法，需要进行年龄大小的判定，确保年龄合理。
5、对于题目集三的7-2，要确保输入的日期字符串符合指定的格式，可以使用正则表达式进行匹配验证，使用合适的日期解析方法，如SimpleDateFormat类来解析日期字符串，并捕获可能的异常，要注意处理日期相差的天数、月数、年数等情况，保证输出信息的准确性和易读性。
6、对于每次题目集的最后一题， 需要注意以下几个方面的内容，输入信息可能按不同的顺序交错输入，因此需要能够正确解析不同类型的输入，并根据需要进行处理，当试卷的总分不等于100分时需要给出警示信息，需要正确计算试卷的总分并与100进行比较，删除题目后，被引用该题目的试卷仍然有效，但是被删除的题目对应的答案将以0分计，并在输出答案时给出失效提示，需要对答卷中的学号和试卷编号进行检查，确保学号和试卷编号在相应的信息中存在，需要根据题目要求输出不同格式的信息，包括试卷总分警示、答题信息、判分信息、题目失效提示等。
(4)改进建议
1、改进题目集一的7-4，可以为成绩类添加toString()方法，方便输出成绩信息。在输入信息解析过程中，可以添加异常处理机制，处理输入信息格式错误的情况。可以封装成绩计算和平均分计算的方法，提高代码的复用性和可维护性。为成绩类和学生类编写单元测试，验证类的方法是否正确实现，确保程序的稳定性和可靠性。
2、改进题目集二的7-1，在编写compareTo方法时，要确保逻辑正确，比较价格时考虑到相等、大于和小于的情况。输入手机信息时，要进行格式检查和异常处理，确保输入的价格为整数。对链表中的手机对象进行排序前，可以先输出未排序前的信息，以及排序后的信息，方便查看排序效果。在查找第四部手机价格是否与链表中某个对象价格相同时，可以遍历链表进行比较，找到相同价格的对象即可。
3、改进题目集二的7-2，在实现构造方法和set方法时，尽量提高代码的健壮性，考虑到可能的异常情况并进行适当的处理。在Main类中，可以通过调用Circle类的方法来实现各个功能，避免重复代码，提高代码的重用性和可读性。在输出圆对象信息时，可以使用toString方法来简化代码，避免重复输出相似的信息。
4、改进题目集三的7-1，可以考虑在print方法中使用String.format()方法，以便更灵活地控制输出格式
5、改进题目集三的7-2，在日期字符串解析和合法性判断时，可以封装成单独的方法，提高代码的复用性和可读性。可以使用异常处理机制来捕获日期解析过程中可能出现的异常，从而提高程序的健壮性。在输出信息时，可以考虑使用String.format()方法或StringBuilder类来构建输出字符串，以便更灵活地控制输出格式。
6、改进题目集三的7-3， 在处理输入信息时，可以使用合适的数据结构（如HashMap、ArrayList等）进行存储和管理，以便快速查找和处理信息。可以将判题逻辑和输出格式化信息的逻辑进行分离，以提高代码的清晰度和可读性。可以编写单元测试来验证程序的各个功能模块是否正常工作，以确保程序的稳定性和可靠性。
(5)总结
通过本阶段的三次题目集的练习，我学到了很多，首先最重要的是让我理解面向对象程序设计的编程思想，其次帮助我巩固对类的理解，以及构造方法和方法的实现，以及方法重写和控制台输入输出的应用，明白了如何使用对象和调用方法，同时通过对象的创建和数据封装，让我明白了如何使用对象来管理数据。并且特别是通过最后一道题目我学会了如何处理复杂的输入输出情况，以及如何设计一个程序来模拟一个小型测试系统，这种综合性的题目涉及到输入输出的格式化处理，数据结构的设计和管理，异常情况的处理等方面，让我更加熟练了编程中的各种技巧和应用场景，但同时我还有许多的不足，我对于语法的掌握还不够熟练， 对于复杂输入输出的处理还有提升空间，特别是在处理异常情况和错误格式时需要更加细致和全面， 对于数据结构的选择和设计可能还需要更深入的理解，以提高程序的效率和可扩展性，在解决问题时，需要更加注重细节和边界情况的考虑，以确保程序的健壮性和稳定性，通过不断的学习和实践，我相信可以逐步克服这些不足，同时逐渐培养起自己面向对象程序设计的编程思想，提高自己的编程水平和能力。
标签：总结性,题目,String,int,样例,PTA,Blog,public,输入 From： https://www.cnblogs.com/23201537zx/p/18145590