OOP课程·PTA题目集1-3总结
一. 前言
- 第一次pta比较简单，主要考察了类的关联与依赖，只有一道大题与4个小题
- 第二次pta比较难，主要考察了类设计，有一道大题与3个小题
- 第三次pta较难，主要考察了类设计，日期类的基本使用，有2个小题与1个大题
二.设计与分析
第一次题目集
- 7-1 设计一个风扇Fan类
源码：
点击查看代码
import java.util.Scanner;
class Fan{
private final int SLOW = 1;
private final int MEDIUM = 2;
private final int FAST = 3;
private int speed;
private boolean on;
private double radius;
private String color;
public Fan(){
this.speed = SLOW;
this.on = false;
this.radius = 5;
this.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 int getSpeed() {
return this.speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public boolean isOn() {
return this.on;
}
public void setOn(boolean on) {
this.on = on;
}
public double getRadius() {
return this.radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public String color() {
return this.color;
}
public void setColor(String color) {
this.color = color;
}
public String toString() {
if (on) {
return "speed " + this.speed +"\n"+ "color " + this.color +"\n"+ "radius " + this.radius+"\n"+"fan is on\n";
}
else {
return "speed " + this.speed +"\n"+ "color " + this.color +"\n"+ "radius " + this.radius+"\n"+"fan is off\n";
}
}
}
public class Main{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
Fan fan1=new Fan();
Fan fan2=new Fan(input.nextInt(),input.nextBoolean(),input.nextDouble(),input.next());
System.out.printf("-------\nDefault\n-------\n");
System.out.print(fan1.toString());
System.out.printf("-------\nMy Fan\n-------\n");
System.out.print(fan2.toString());
}
类图：
分析：按照题意设计风扇类，对输入输出进行处理即可
- 7-2 类和对象的使用
源码：
点击查看代码
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 name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getStudentID() {
return studentID;
}
public void setStudentID(String studentID) {
this.studentID = studentID;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public String toString(){
return "姓名："+this.name+"，性别："+this.sex+"，学号：" + this.studentID+",年龄："+this.age+",专业："+this.major;
}
public void printlnfo(){
System.out.printf("%s",toString());
}
}
public class Main{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
Student student=new Student(input.next(),input.next(),input.nextInt(),input.next(),input.next());
student.printlnfo();
}
}
类图：
分析：按题意设计学生类，创建学生对象并初始化，再输出学生信息
- 7-3 成绩计算-1-类、数组的基本运用
源码：
点击查看代码
import java.util.Scanner;
import java.text.DecimalFormat;
import java.math.BigDecimal;
class Student{
private String studentID;
private String name;
private int chineseGrade;
private int mathGrade;
private int physicsGrade;
public Student(){
}
public Student(String studentID,String name,int chineseGrade,int mathGrade,int physicsGrade){
this.studentID=studentID;
this.name=name;
this.chineseGrade=chineseGrade;
this.mathGrade=mathGrade;
this.physicsGrade=physicsGrade;
}
public int sum(){
return this.chineseGrade+this.mathGrade+this.physicsGrade;
}
public double average(){
double f=(double)this.sum()/3.00;
return f;
}
public String toString(){
double f=this.average();
DecimalFormat df = new DecimalFormat("#.00");
return this.studentID+" "+this.name+" "+this.sum()+" "+df.format(f)+"\n";
}
}
public class Main{
public static void main(String[]args){
Scanner input =new Scanner(System.in);
Student student1=new Student(input.next(),input.next(),input.nextInt(),input.nextInt(),input.nextInt());
Student student2=new Student(input.next(),input.next(),input.nextInt(),input.nextInt(),input.nextInt());
Student student3=new Student(input.next(),input.next(),input.nextInt(),input.nextInt(),input.nextInt());
Student student4=new Student(input.next(),input.next(),input.nextInt(),input.nextInt(),input.nextInt());
Student student5=new Student(input.next(),input.next(),input.nextInt(),input.nextInt(),input.nextInt());
System.out.print(student1.toString());
System.out.print(student2.toString());
System.out.print(student3.toString());
System.out.print(student4.toString());
System.out.print(student5.toString());
}
}
类图：
分析：按照题意设计学生类，初始化对象并输出成绩。
- 7-4成绩计算-2-关联类
源码：
点击查看代码
import java.util.Scanner;
import java.text.DecimalFormat;
import java.math.BigDecimal;
class Grade{
private int usualGrade;
private int finalGrade;
public Grade(){
}
public Grade(int usualGrade,int finalGrade){
this.usualGrade=usualGrade;
this.finalGrade=finalGrade;
}
public int totalGrade(){
return (int)(this.usualGrade*0.4+this.finalGrade*0.6);
}
public int getUsualGrade(){
return this.usualGrade;
}
public int getFinalGrade(){
return this.finalGrade;
}
}
class Student{
private String studentID;
private String name;
private Grade chineseGrade;
private Grade mathGrade;
private Grade physicsGrade;
public Student(){
}
public Student(String studentID,String name,Grade chineseGrade,Grade mathGrade,Grade physicsGrade){
this.studentID=studentID;
this.name=name;
this.chineseGrade=chineseGrade;
this.mathGrade=mathGrade;
this.physicsGrade=physicsGrade;
}
public int sumTotal(){
return this.chineseGrade.totalGrade()+this.mathGrade.totalGrade()+this.physicsGrade.totalGrade();
}
public int sumUsual(){
return this.chineseGrade.getUsualGrade()+this.mathGrade.getUsualGrade()+this.physicsGrade.getUsualGrade();
}
public int sumFinal(){
return this.chineseGrade.getFinalGrade()+this.mathGrade.getFinalGrade()+this.physicsGrade.getFinalGrade();
}
public double averageTotal(){
double f=(double)this.sumTotal()/3.00;
return f;
}
public double averageUsual(){
double f=(double)this.sumUsual()/3.00;
return f;
}
public double averageFinal(){
double f=(double)this.sumFinal()/3.00;
return f;
}
public String toString(){
double f1=this.averageTotal();
double f2=this.averageUsual();
double f3=this.averageFinal();
DecimalFormat df = new DecimalFormat("#.00");
return this.studentID+" "+this.name+" "+this.sumTotal()+" "+df.format(f2)+" "+df.format(f3)+" "+df.format(f1)+"\n";
}
}
public class Main{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
Student []stu=new Student[3];
for(int i=0;i<3;i++){
Grade chineseGrade=new Grade();
Grade mathGrade=new Grade();
Grade physicsGrade=new Grade();
String studentID11=input.next();
String name11=input.next();
String subject1=input.next();
switch(subject1){
case "语文":chineseGrade=new Grade(input.nextInt(),input.nextInt());break;
case "数学":mathGrade=new Grade(input.nextInt(),input.nextInt());break;
case "物理":physicsGrade=new Grade(input.nextInt(),input.nextInt());break;
}
String studentID12=input.next();
String name12=input.next();
String subject2=input.next();
switch(subject2){
case "语文":chineseGrade=new Grade(input.nextInt(),input.nextInt());break;
case "数学":mathGrade=new Grade(input.nextInt(),input.nextInt());break;
case "物理":physicsGrade=new Grade(input.nextInt(),input.nextInt());break;
}
String studentID13=input.next();
String name13=input.next();
String subject3=input.next();
switch(subject3){
case "语文":chineseGrade=new Grade(input.nextInt(),input.nextInt());break;
case "数学":mathGrade=new Grade(input.nextInt(),input.nextInt());break;
case "物理":physicsGrade=new Grade(input.nextInt(),input.nextInt());break;
}
stu[i]=new Student(studentID11,name11,chineseGrade,mathGrade,physicsGrade);
System.out.print(stu[i].toString());
}
}
}
类图：
分析：运用了类的关联，把成绩类作为学生类的属性，处理输入，再输出
- 7-5答题判题程序-1
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
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:
多个题目，题号顺序与输入顺序不同。例如：
2
#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。
源码：
类图：
分析：设计3个类，问题类，试卷类，答卷类。先对输入字符串进行处理拆分，保存到问题中，把题目加到试卷中，把试卷加到答卷中，然后对答案字符串拆分，保存到答卷中，最后进行判题并输出。
第二次题目集
- 7-1 手机按价格排序、查找
源码：
点击查看代码
import java.util.*;
class MobilePhone implements Comparable<MobilePhone> {
private String type;
private int price;
public MobilePhone(){
}
public MobilePhone(String type,int price){
this.type=type;
this.price=price;
}
public int getPrice(){
return this.price;
}
public String getType(){
return this.type;
}
public String toString(){
return "型号："+this.type+"，价格："+this.price;
}
@Override
public int compareTo(MobilePhone otherMobilePhone) {
return this.price - otherMobilePhone.price;
}
}
public class Main{
public static void main(String[]args){
Scanner input =new Scanner(System.in);
LinkedList<MobilePhone> MobilePhoneList = new LinkedList<>();
MobilePhoneList.add(new MobilePhone(input.next(),input.nextInt()));
MobilePhoneList.add(new MobilePhone(input.next(),input.nextInt()));
MobilePhoneList.add(new MobilePhone(input.next(),input.nextInt()));
System.out.println("排序前，链表中的数据：");
for(int i=0;i<3;i++){
System.out.printf("%s\n",(MobilePhoneList.get(i)).toString());
}
Collections.sort(MobilePhoneList);
System.out.println("排序后，链表中的数据：");
for(int i=0;i<3;i++){
System.out.printf("%s\n",(MobilePhoneList.get(i)).toString());
}
MobilePhone goal=new MobilePhone(input.next(),input.nextInt());
int flag=0;
for(int i=0;i<3;i++){
if(goal.getPrice()==(MobilePhoneList.get(i)).getPrice()){
System.out.println(goal.getType()+"与链表中的"+(MobilePhoneList.get(i)).getType()+"价格相同");
flag=1;
//break;
}
}
if(flag==0){
System.out.print("链表中的对象，没有一个与"+goal.getType()+"价格相同的");
}
}
}
类图：
分析：设计手机类，了解相关知识可实现Comparable接口，重写compareTo方法，完成排序
- 7-2sdut-oop-4-求圆的面积（类与对象）
源码：
点击查看代码
import java.util.*;
class Circle{
private int radius;
public Circle(){
this.radius=2;
System.out.println("This is a constructor with no para.");
}
public Circle(int radius){
if(radius>0)
this.radius=radius;
else
this.radius=2;
System.out.println("This is a constructor with para.");
}
public void setRadius(int radius){
if(radius>0)
this.radius=radius;
else
this.radius=2;
}
public int getRadius(){
return this.radius;
}
public double getArea(){
return this.radius*this.radius*Math.PI;
}
public String toString( ){
return "Circle [radius=" + this.radius + "]";
}
}
public class Main{
public static void main(String[]args){
Scanner input =new Scanner(System.in);
Circle c1=new Circle();
System.out.printf("%s\n",c1.toString());
System.out.printf("%.2f\n",c1.getArea());
Circle c2=new Circle();
System.out.printf("%s\n",c2.toString());
System.out.printf("%.2f\n",c2.getArea());
c1.setRadius(input.nextInt());
System.out.printf("%s\n",c1.toString());
System.out.printf("%.2f\n",c1.getArea());
c2=new Circle(input.nextInt());
System.out.printf("%s\n",c2.toString());
System.out.printf("%.2f\n",c2.getArea());
}
}
类图：
分析：该题很简单，了解类和对象的相关知识就能做出了
- 7-3 Java类与对象-汽车类
源码：
点击查看代码
import java.util.*;
/**
* @author Teacher
* 主类，用来在pta中运行。
* 其中有一处代码需要完善
*/
public class Main {
public static void main(String[] args) {
// 此处填写合适的代码【1】
// 生成汽车实例
float a=0;
Car car=new Car("bob",a,a);
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】
this.curSpeed=curSpeed;
}
// 提供停车
public void stop() {
// 此处填写合适的代码【3】
this.curSpeed=0;
this.curDirInDegree=0;
}
}
类图：
分析：该题很简单，了解类和对象的相关知识就能做出了。
- 7-4答题判题程序-2
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=22false.
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=~5~false
2+2=~22~false
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=~5~false
2+2=~22~false
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=~5~false
2+2=~4~true
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=~5~false
1+1=~22~false
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=~5~true
2+2=~22~false
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=~5~true
2+2=~22~false
70 0~70
3+2=~5~true
2+2=~4~true
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=~5~true
2+2=~22~false
7 0~7
3+2=~5~true
2+2=~4~true
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=~5~true
2+2=~22~false
7 0~7
2+2=~5~false
1+1=~4~false
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
源码：
类图：
分析：先用正则表达式对输入的每行字符串进行分类，分为题目，试卷，答卷三种信息。再依次对题目试卷答卷类字符串进行拆分，设置到题目，试卷，答卷中。再对答案进行校验，最后先输出分数提示，再输出答卷及判分信息。
第三次题目集
- 7-1面向对象编程(封装性)
源码：
点击查看代码
import java.util.*;
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.setSid(sid);
this.setName(name);
this.setAge(age);
this.setMajor(major);
}
public String getID() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>=0){
this.age=age;
}
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public void print(){
System.out.println("学号："+sid+"，姓名："+name+"，年龄："+age+"，专业："+major);
}
}
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();
}
}
/* 请在这里填写答案 */
类图：
分析：该题很简单，了解类和对象的相关知识就能做出了。
- 7-2 jmu-java-日期类的基本使用
源码：
点击查看代码
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String dateStr1 = input.nextLine();
String dateStr2 = input.nextLine();
if (!isValidDate(dateStr1)) {
System.out.println(dateStr1 + "无效!");
}
else {
Date date1 = parseDate(dateStr1);
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(date1);
int year = calendar1.get(Calendar.YEAR);
boolean isLeapYear = isLeapYear(year);
if(isLeapYear){
System.out.println(dateStr1 +"是闰年.");
}
int week=calendar1.get(Calendar.DAY_OF_WEEK);
if(week==1){
week=7;
}
else{
week-=1;
}
System.out.println(dateStr1 + "是当年第" + calendar1.get(Calendar.DAY_OF_YEAR) + "天,当月第" + calendar1.get(Calendar.DAY_OF_MONTH) + "天,当周第" + week + "天.");
}
String[] dates = dateStr2.split(" ");
boolean isValid = true;
for (int i=0;i<=1;i++) {
if (!isValidDate(dates[i])) {
isValid = false;
break;
}
}
if(isValid==false){
System.out.println(dates[0]+"或" +dates[1]+ "中有不合法的日期.");
}
if (isValid && compareDates(dates[0], dates[1]) <= 0) {
Date startDate = parseDate(dates[0]);
Date endDate = parseDate(dates[1]);
long diffDays = getDifferenceInDays(startDate, endDate);
int diffMonths = getDifferenceInMonths(startDate,endDate);
int diffYears = getDifferenceInYears(startDate, endDate);
System.out.printf("%s与%s之间相差%d天,所在月份相差%d,所在年份相差%d.",dates[1],dates[0],diffDays,diffMonths,diffYears);
}
if (isValid){
warnning(dates[0],dates[1]);
}
}
public static boolean isValidDate(String dateStr) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Pattern pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
Matcher matcher = pattern.matcher(dateStr);
if(matcher.find()&&dateStr.length()==10){
sdf.setLenient(false);
try {
sdf.parse(dateStr);
return true;
} catch (ParseException e) {
return false;
}
}
else{
return false;
}
}
public static Date parseDate(String dateStr) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try {
return sdf.parse(dateStr);
} catch (ParseException e) {
return null;
}
}
public static boolean isLeapYear(int year) {
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}
public static int compareDates(String dateStr1, String dateStr2) {
Date date1 = parseDate(dateStr1);
Date date2 = parseDate(dateStr2);
return date1.compareTo(date2);
}
public static long getDifferenceInDays(Date startDate, Date endDate) {
long diff = endDate.getTime() - startDate.getTime();
return diff / (24 * 60 * 60 * 1000);
}
public static int getDifferenceInMonths(Date startDate, Date endDate) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
int diffYears = endCalendar.get(Calendar.YEAR) - startCalendar.get(Calendar.YEAR);
int diffMonths = endCalendar.get(Calendar.MONTH) - startCalendar.get(Calendar.MONTH);
return /*diffYears * 12+*/ diffMonths;
}
public static int getDifferenceInYears(Date startDate, Date endDate) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
return endCalendar.get(Calendar.YEAR) - startCalendar.get(Calendar.YEAR);
}
public static void warnning(String data1,String data2){
Date startDate = parseDate(data1);
Date endDate = parseDate(data2);
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
if(endCalendar.before(startCalendar)){
System.out.print(data2+"早于"+data1+",不合法!");
}
}
}
分析：主要考察了日期类中相关方法的使用
- 7-3 答题判题程序-3
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=~5~false
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=~5~true
4+6=~22~false.
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=~5~false
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=~2~true
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=~5~false
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=~5~false
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=~5~false
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=~5~false
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=~5~false
中国第一颗原子弹的爆炸时间~4~false
20201103 Tom: 0 0~0
源码：
类图：
分析：设计6个类，学生类，问题类，试卷类，学生答卷类，答卷类，输出类。有5种信息，先用正则表达式对每行字符串进行匹配分类，都不匹配则输出警告。再依次对字符串拆分，保存到题目试卷答卷学生中。把题目保存到试卷中，试卷保存到答卷中，答案保存到学生答卷中，学生答卷再保存到答卷中。最后进行判题并依次输出。
3.采坑心得
1.审题：看清楚题目要求，对与输入格式要仔细看，看清楚具体的格式才能更好的使用正则表达式去比配拆分等等，看懂答案输出顺序是怎样的
2.对于边界要分清楚，不然经常会非零返回
3.对于类设计结构要清晰，不然整体思路会错，在后面再改可能和重新写一样
4.对于answe is null的输出，应该是与题目的顺序一致（一开始在最后一起输出，一直没发现有错）
4.改进建议
1.对于类的职责要划分清楚，要遵守单一职责，不能全在主类中写
2.对于每一种功能的实现，应该创建一个类来履行这些职责
3.对于非零返回，应该仔细检查代码中是否有越界或读到了空
4.对类的设计应该更加具体明确
5.总结
这三次的作业总体来说较难，题目量虽然也不多，但是有些题目还是需要静下心来思考怎么去实现，要用心设计类，想好每个类应该有哪些功能。
这几次作业让我发现了自己一个问题，不会去思考哪些功能可以设计成类，喜欢把东西都放在主类中写。我感觉到没有完全掌握类的设计，应该多去思考怎么做类设计。
浙公网安备 33010602011771号