标签：总结题目 String int pta 实验信息 public 输入

刚开始接触java，感到有些吃力，可能是因为C语言基础不牢的缘故，我的Java水平还有待提高。
pta1：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
输出样例:
在这里给出相应的输出。例如：

speed 2
color Red
radius 6.0
fan is on

此次作业中我的水平还很低，面向对象水平较差，无法成功完成代码；
源码：

点击查看代码

import java.util.*;
public class Main {
static class Fan{
    public final int SLOW=1;
    public final int MEDIUM=2;
    public final int FAST=3;
    private int speed=SLOW;
    private boolean on=false;
    private double radius=5;
    private String color="white";
    public Fan() {}
    public Fan1(int fanSpeed,boolean fanOn,double fanRadius,String fanColor){
        speed=fanSpeed;
        on=fanOn;
        radius=fanRadius;
        color=fanColor;
    }
    public String toString() { 
        String s="speed "+speed+"\n"+"color "+color+"\n"+"radius "+radius+"\n";
        if(on==false) {
            s+="fan is off";
        }
        else if(on==true){
            s+="fan is on";
        }
        return s;
    }
}
    public static void main(String[] args) {
        System.out.println("-------\n"+"Default\n"+"-------");
        Fan x=new Fan();
        System.out.println(x.toString());
        System.out.println("-------\n"+"My Fan\n"+"-------");
        Scanner input=new Scanner(System.in);
        int Speed=input.nextInt() ;
        boolean On=input.nextBoolean();
        double Radius=input.nextDouble();
        String Color=input.next();
        Fan y=new Fan.Fan1(Speed,On,Radius,Color);
        System.out.println(y.toString());
    }
}

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,专业：计算机科学

源码：

点击查看代码

import java.util.*;
import java.util.Scanner;
public class Main {
    static class Student{
    private String name="张三";
    private String sex="男";
    private int studentID=2022120;
    private int age=23;
    private String major="计算机科学";
    public Student() {}
    public Student(String name,String sex,int studentID,int age,String major){
        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 int getStudentID() {
        return studentID;
    }
    public void setStudentID(int 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 "Student [name=" + name + ", sex=" + sex + ", studentID=" 
            + studentID + ", age=" + age + ", major=" + major + "]";
    }
    public void printInfo() {
        System.out.println("姓名：" + name);
        System.out.println("性别：" + sex);
        System.out.println("学号：" + studentID);
        System.out.println("年龄：" + age);
        System.out.println("专业：" + major);
    }
}
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String name = input.nextLine();
        String sex = input.nextLine();
        int studentID = input.nextInt();
        int age = input.nextInt();
        String major = input.nextLine();
        Student student = new Student(name, sex, studentID, age, major);
        student.printInfo();
    }
}

该 Java 程序创建一个 Student 类，表示学生的个人信息。Student 类具有五个私有成员变量，分别用于存储姓名、性别、学号、年龄和专业。它还具有用于获取和设置这些变量值的 getter 和 setter 方法。

在 main 方法中，程序从用户那里读取学生信息，并创建 Student 对象。printInfo() 方法用于打印学生的个人信息。

以下是该程序的逐步分析：

Student 类：

具有私有成员变量 name、sex、studentID、age 和 major，分别表示学生的姓名、性别、学号、年龄和专业。
具有 getter 和 setter 方法用于获取和设置这些成员变量的值。
具有一个无参构造函数和一个带参数的构造函数，用于初始化学生的个人信息。
具有 toString() 方法，用于返回学生的字符串表示。
具有 printInfo() 方法，用于打印学生的个人信息。
main 方法：

从用户那里读取学生的姓名、性别、学号、年龄和专业。
创建 Student 对象，并使用用户提供的信息对其进行初始化。
调用 printInfo() 方法打印学生的个人信息。
该程序允许用户输入学生信息，并创建一个对象来表示该信息。然后打印学生的个人信息

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
源码：

点击查看代码

import java.util.Scanner;
class Student {
    private String id;
    private String name;
    private int chinese;
    private int math;
    private int physics;
    public Student(String id, String name, int chinese, int math, int physics) {
        this.id = id;
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.physics = physics;
    }
    public int calculateTotal() {
        return chinese + math + physics;
    }
    public double calculateAverage() {
        return calculateTotal() / 3.0;
    }
    public String getName() {
        return name;
    }
    public String getId() {
        return id;
    }
    public int getChinese() {
        return chinese;
    }
    public int getPhysics() {
        return physics;
    }
    public int getMath() {
        return math;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Student[] students = new Student[5];
        for (int i = 0; i < 5; i++) {
            String[] stu = input.nextLine().split(" ");
            String name = stu[1];
            String id = stu[0];
            int math = Integer.parseInt(stu[3]);
            int chinese = Integer.parseInt(stu[2]);
            int physics = Integer.parseInt(stu[4]);
            students[i] = new Student(id, name, chinese, math, physics);
        }
        for (int i = 0; i < 5; i++) {
            int total = students[i].calculateTotal();
            double average = students[i].calculateAverage();
            System.out.printf("%s %s %d %.2f\n",students[i].getId(), students[i].getName(), total, average);
        }
    }
}

分析：该 Java 程序创建了一个 Student 类，表示学生的个人信息和成绩。Student 类具有以下成员变量和方法：

成员变量：
- id：学生的学号
- name：学生姓名
- chinese：语文成绩
- math：数学成绩
- physics：物理成绩
方法：
- 构造函数：初始化学生的个人信息和成绩
- calculateTotal()：计算学生的总成绩
- calculateAverage()：计算学生的平均成绩
- getter 方法：获取学生的个人信息和成绩

在 main 方法中，程序执行以下操作：

创建一个 Student 数组 students，最多可存储 5 个学生的信息。
使用 Scanner 从用户那里读取 5 个学生的个人信息和成绩。
使用这些信息创建 Student 对象并将其存储在 students 数组中。
遍历 students 数组，并为每个学生计算总成绩和平均成绩。
打印每个学生的学号、姓名、总成绩和平均成绩。

该程序允许用户输入 5 个学生的个人信息和成绩，并计算每个学生的总成绩和平均成绩。然后，它打印每个学生的这些信息。

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

源码：

点击查看代码

import java.util.Scanner;
class Grades{
    private int grade1;
    private int grade2;
    public Grades(int grade1,int grade2){
        this.grade1=grade1;
        this.grade2=grade2;
    }
    public int getgrade1(){
        return grade1;
    }
    public int getgrade2(){
        return grade2;
    }
    public int Totalgrades(){
        return (int)(grade1*0.4+grade2*0.6);
    }
}
class Student{
    private String id;
    private String name;
    private Grades chinese;
    private Grades math;
    private Grades physics;
    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 math;
    }
    public void setMathscore(Grades math){
        this.math = math;
    }
    public Grades getPhysicsscore(){
        return physics;
    }
    public void setPhysicsscore(Grades physics){
        this.physics = physics;
    }
    public Grades getChinesescore(){
        return chinese;
    }
    public void setChinesescore(Grades chinese){
        this.chinese = chinese;
    }
    public int getallscore(){
        return chinese.Totalgrades()+math.Totalgrades()+physics.Totalgrades();
    }
    public double getavgscore(){
        double sum=chinese.Totalgrades()+math.Totalgrades()+physics.Totalgrades();
        return (double)(sum/3);
    }
    public double getuavgscore(){
        double sum=chinese.getgrade1()+math.getgrade1()+physics.getgrade1();
        return (double)(sum/3);
    }
    public double getfavgscore(){
        double sum=chinese.getgrade2()+math.getgrade2()+physics.getgrade2();
        return (double)(sum/3);
    }
}
public class Main{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        Student[] stu=new Student[3];
        Grades[] stu1=new Grades[3];
        int a=0;
        for(int i=0;i<9;i++){
            String id= input.next();
            String name =input.next();
            String subject = input.next();
            int grade1= input.nextInt();
            int grade2 =input.nextInt();
            int j=i%3;
            if(j==0){
                stu[a]=new Student(id,name);
                stu[a].setChinesescore(new Grades(grade1,grade2));
            }
            if(j==1){
                stu[a].setMathscore(new Grades(grade1,grade2));
            }
            if(j==2){
                stu[a].setPhysicsscore(new Grades(grade1,grade2));
                a++;
            }
        }
        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()));
        }
    }
}

分析：
该 Java 程序创建一个 Student 类，表示学生的个人信息和成绩。Student 类具有以下成员变量和方法：

成员变量：
- id：学生的学号
- name：学生姓名
- chinese：语文成绩
- math：数学成绩
- physics：物理成绩
方法：
- 构造函数：初始化学生的个人信息和成绩
- getter 和 setter 方法：获取和设置学生的个人信息和成绩
- getallscore()：计算学生的总成绩
- getavgscore()：计算学生的平均成绩（总成绩的平均数）
- getuavgscore()：计算学生的平均平时成绩（平时成绩的平均数）
- getfavgscore()：计算学生的平均期末成绩（期末成绩的平均数）

在 main 方法中，程序执行以下操作：

创建 3 个 Student 对象和 3 个 Grades 对象数组，分别用于存储学生的个人信息和成绩。
使用 Scanner 从用户那里读取每个学生的个人信息和成绩，并使用这些信息更新相应的 Student 对象。
遍历 Student 数组，并为每个学生计算总成绩、平均成绩、平均平时成绩和平均期末成绩。
打印每个学生的学号、姓名、总成绩、平均平时成绩、平均期末成绩和平均成绩。

该程序允许用户输入 3 个学生的个人信息和成绩，并计算每个学生的总成绩、平均成绩、平均平时成绩和平均期末成绩。然后，它打印每个学生的这些信息。
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

分析：这道题目因为自身实力原因未能成功写出来，现在想来因为自身类与对象的知识未能完全掌握消化，应当多花时间进行钻研

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价格相同的

源码

点击查看代码

import java.util.*;
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;
    }
    public int compareTo(MobilePhone other) {
        return Integer.compare(this.price, other.price);
    }
    public String toString() {
        return "型号：" + type + "，价格：" + price;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        List<MobilePhone> phones = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            String sj1 = input.nextLine();
            String[] parts = sj1.split(" ");
            String type = parts[0];
            int price = Integer.parseInt(parts[1]);
            phones.add(new MobilePhone(type, price));
        }
        System.out.println("排序前，链表中的数据：");
        for (MobilePhone phone : phones) {
            System.out.println(phone);
        }
        Collections.sort(phones);
        System.out.println("排序后，链表中的数据：");
        for (MobilePhone phone : phones) {
            System.out.println(phone);
        }
        String sj2 = input.nextLine();
        String[] parts = sj2.split(" ");
        String type = parts[0];
        int price = Integer.parseInt(parts[1]);
        MobilePhone fourthPhone = new MobilePhone(type, price);
        boolean found = false;
        MobilePhone matchingPhone = null;
        for (MobilePhone phone : phones) {
            if (phone.getPrice() == fourthPhone.getPrice()) {
                found = true;
                matchingPhone = phone;
                break;
            }
        }
        if (found) {
            System.out.println(fourthPhone.getType() + "与链表中的" + matchingPhone.getType() + "价格相同");
        } else {
            System.out.println("链表中的对象，没有一个与" + fourthPhone.getType() + "价格相同的");
        }
    }
}

分析：该 Java 程序使用 `Comparable` 接口对移动手机进行排序，并搜索价格匹配的手机。以下是其工作原理：

MobilePhone 类实现了 Comparable 接口，这允许它按价格进行比较。compareTo 方法比较两个 MobilePhone 对象的价格，并返回一个负整数、零或正整数，具体取决于哪个对象的手机价格更低、相等或更高。
main 方法执行以下操作：
- 从用户那里读取 3 个移动手机的详细信息，并使用这些信息创建 MobilePhone 对象。
- 将这些对象添加到一个 List（链表）中。
- 打印排序前的链表中的手机信息。
- 使用 Collections.sort 方法对链表中的手机按价格排序。
- 打印排序后的链表中的手机信息。
- 从用户那里读取第四个移动手机的详细信息，并创建一个新的 MobilePhone 对象。
- 遍历链表中的手机，并检查是否存在价格与第四个手机相同。如果找到匹配项，则打印信息，否则打印一条消息，说明没有匹配项。

该程序允许用户输入 4 个移动手机的详细信息，并按照价格对前 3 个手机进行排序。然后，它检查第四个手机的价格是否与前 3 个手机的任何一个匹配。该程序打印排序后的手机信息和有关匹配项的信息（如果存在）。

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

源码：

点击查看代码

import java.util.*;
import java.text.DecimalFormat;
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){
        Circle c1=new Circle();
        System.out.println(c1);
        System.out.println(formatArea(c1.getArea()));
        Circle c2=new Circle();
        System.out.println(c2);
        System.out.println(formatArea(c2.getArea()));
        Scanner input=new Scanner(System.in);
        int radius=input.nextInt();
        c2.setRadius(radius);
        System.out.println(c2);
        System.out.println(formatArea(c2.getArea()));
        radius=input.nextInt();
        Circle c3=new Circle(radius);
        System.out.println(c3);
        System.out.println(formatArea(c3.getArea()));
    }
    public static String formatArea(double area) {
        DecimalFormat df = new DecimalFormat("#.00");
        return df.format(area);
    }
}

分析：该 Java 程序使用构造函数和方法创建和操作 Circle 对象，计算它们的面积并格式化输出。以下是其工作原理：

Circle 类具有以下成员变量和方法：
- 成员变量：
  - radius：圆的半径
- 方法：
  - 构造函数：初始化圆的半径
  - setRadius：设置圆的半径
  - getRadius：获取圆的半径
  - getArea：计算圆的面积
  - toString：返回圆的字符串表示形式
main 方法执行以下操作：
- 创建两个 Circle 对象，c1 和 c2，分别使用无参构造函数和默认半径 2。
- 打印 c1 和 c2 的信息，以及它们的面积（使用 formatArea 方法格式化为两位小数）。
- 从用户那里获取一个半径，并使用 setRadius 方法设置 c2 的半径。
- 打印 c2 的信息和格式化的面积。
- 从用户那里获取另一个半径，并使用带参数的构造函数创建新的 Circle 对象 c3。
- 打印 c3 的信息和格式化的面积。
formatArea 方法使用 DecimalFormat 类将给定的面积值格式化为两位小数的字符串。

该程序允许用户创建和操作圆对象，计算它们的面积，并格式化输出结果。它演示了构造函数、方法和格式化输出的使用。

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

源码：

点击查看代码

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Car car = new Car("bob", 0.0f, 0.0f);
        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() {
    }
    public Car(String ownerName, float speed, float dirInDegree) {
        this.ownerName = 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) {
        this.curSpeed = curSpeed;
    }
    public void stop() {
        this.curSpeed = 0;
    }
}

分析：该 Java 程序创建了一个 Car 对象，该对象具有所有者姓名、当前速度和当前方向（以度为单位）等属性。它演示了使用构造函数、方法和访问器来操作和检索对象属性。

以下是程序的工作原理：

主函数 main 创建一个 Car 对象 car，并为其设置所有者姓名、当前速度和当前方向。它打印出对象的初始状态。
然后，它调用 changeSpeed 方法将汽车的速度更改为 10。并再次打印汽车的状态。
接下来，它调用 stop 方法使汽车停止，并将汽车的速度设置为 0。并最后打印汽车的状态。

该程序演示了如何使用对象来存储和操作数据，以及如何使用方法来修改对象的状态。

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=₅true

     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，建议增加答题类，类的内容以及类之间的关联自行设计。

分析：加入新知识后我手忙脚乱，未能写出此道题目。
源码：

点击查看代码

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;
    }
    public boolean checkAnswer(String userAnswer) {
        return answer.equals(userAnswer);
    }
}
class TestPaper {
    private int number;
    private Map<Integer, Integer> questions;
    private int totalScore;
    public TestPaper(int number) {
        this.number = number;
        this.questions = new HashMap<>();
        this.totalScore = 0;
    }
    public void addQuestion(int questionNumber, int score) {
        questions.put(questionNumber, score);
        totalScore += score;
    }
    public int getNumber() {
        return number;
    }
    public int getTotalScore() {
        return totalScore;
    }
    public Map<Integer, Integer> getQuestions() {
        return questions;
    }
}
class AnswerSheet {
    private int testPaperId;
    private Map<Integer, String> answers;
    public AnswerSheet(int testPaperId) {
        this.testPaperId = testPaperId;
        this.answers = new HashMap<>();
    }
    public void addAnswer(int questionId, String answer) {
        answers.put(questionId, answer);
    }
    public int getTestPaperId() {
        return testPaperId;
    }
    public Map<Integer, String> getAnswers() {
        return answers;
    }
}
public class Main {
    private Map<Integer, Question> questions;
    private Map<Integer, TestPaper> testPapers;
    private Map<Integer, AnswerSheet> answerSheets;
    public Main() {
        questions = new HashMap<>();
        testPapers = new HashMap<>();
        answerSheets = new HashMap<>();
    }
    public void inputAll(Scanner input) {
        while (input.hasNext()) {
            String line = input.nextLine();
            if ("end".equals(line)) {
                break;
            }
            if (line.startsWith("#N:")) {
                String[] parts = line.split("#N:|#Q:|#A:");
                if (parts.length == 4) {
                    int id = Integer.parseInt(parts[1].trim());
                    String content = parts[2].trim();
                    String answer = parts[3].trim();
                    Question question = new Question(id, content, answer);
                    questions.put(id, question);
                }
                else if (line.startsWith("#T:")) {
                    String[] parts = line.split("#T:| ");
                    if (parts.length > 1) {
                        int testPaperId = Integer.parseInt(parts[1].trim());
                        TestPaper testPaper = testPapers.computeIfAbsent(testPaperId, TestPaper::new);
                        String[] questionParts = parts[2].split(" ");
                        for (String questionPart : questionParts) {
                            String[] questionDetail = questionPart.split("-");
                            if (questionDetail.length == 2) {
                                int questionId = Integer.parseInt(questionDetail[0].trim());
                                int score = Integer.parseInt(questionDetail[1].trim());
                                testPaper.addQuestion(questionId, score);
                            }
                        }
                    }
                }
            }
        }
    }
                else if (line.startsWith("#S:")) {
                String[] parts = line.split("#S:|#A: ");
                if (parts.length > 2) {
                    int testPaperId = Integer.parseInt(parts[1].trim());
                    AnswerSheet answerSheet = new AnswerSheet(testPaperId);
                    for (int i = 2; i < parts.length; i++) {
                        String answer = parts[i].trim();
                        answerSheet.addAnswer(i - 2, answer); // 假设答案的顺序与题目顺序相同
                    }
                    answerSheets.put(testPaperId, answerSheet);
                }
            }
            }
    public void evaluateAnswerSheets() {
        for (Map.Entry<Integer, AnswerSheet> entry : answerSheets.entrySet()) {
            int testPaperId = entry.getKey();
            AnswerSheet answerSheet = entry.getValue();
            TestPaper testPaper = testPapers.get(testPaperId);
            Map<Integer, Integer> questionsMap = testPaper.getQuestions();
            Map<Integer, String> answersMap = answerSheet.getAnswers();
            int totalScore = 0;
            Set<Integer> questionIds = questionsMap.keySet();
            for (Integer questionId : questionIds) {
                String userAnswer = answersMap.getOrDefault(questionId, "answer is null");
                Question question = questions.get(questionId);
                if (question != null) {
                    boolean isCorrect = question.checkAnswer(userAnswer);
                    int score = questionsMap.get(questionId);
                    if (isCorrect) {
                        totalScore += score;
                    }
                }
            }
            for (Map.Entry<Integer, String> entry : answersMap.entrySet()) {
                Integer questionId = entry.getKey();
                String userAnswer = entry.getValue();
                System.out.println(questionId + ": " + userAnswer + (userAnswer.equals("answer is null") ? " (无答案)" : ""));
            }
            System.out.println("判分信息: " + totalScore + "~" + totalScore);
        }
    }
    public static void main(String[] args) {
        Main main = new Main();
        Scanner input = new Scanner(System.in);
        main.inputQuestions(input);
        main.inputTestPapers(input);
        main.inputAnswerSheets(input);
        main.evaluateAnswerSheets();
    }
}

此代码并不正确；

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，专业：软件工程

源码：

点击查看代码

import java.util.*;
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();
    }
}

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;
        this.major=major;
        if(age>18&&age<30){
            this.age=age;
        }
    }
    public String getSid() {
        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 >= 18 && age <= 30) {
            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);
    }
}

分析：该 Java 程序使用构造函数和方法来创建和操作 `Student` 对象，这些对象具有学号、姓名、年龄和专业等属性。以下是其工作原理：

主函数 main 从用户那里读取输入并创建两个 Student 对象：
- student1 使用无参构造函数创建，然后使用 set 方法设置其属性。
- student2 使用带参数的构造函数创建，该构造函数直接设置对象的属性。
然后，程序调用 print 方法来打印每个学生的详细信息。

Student 类具有以下成员变量和方法：

成员变量：
- sid：学生的学号
- name：学生的姓名
- age：学生的年龄
- major：学生的专业
方法：
- 构造函数：初始化学生的属性
- set 方法：设置学生的属性（setSid、setName、setAge、setMajor）
- get 方法：获取学生的属性（getSid、getName、getAge、getMajor）
- print 方法：打印学生的详细信息

该程序演示了如何使用构造函数和方法创建和操作对象，以及如何使用 set 和 get 方法设置和检索对象属性。

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,不合法!

源码：

点击查看代码

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.Year;
import java.util.*;
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;
    }
}

分析：这个 Java 程序解析用户输入的日期并执行以下任务：

检查给定的日期是否有效，格式为 yyyy-MM-dd。
计算日期是当年的第幾天、当月的第幾天和当周的第幾天。
计算两个给定日期之间的天数、相差月份和相差年份。

以下是程序的工作原理：

主函数 main 从用户那里读取两个字符串，一个表示日期 line，另一个表示日期范围 nextLine。
程序使用 isValidDate 方法来验证给定的日期是否有效。该方法使用正则表达式和 ParsePosition 来检查日期的格式和范围。
如果日期有效，程序使用 Calendar 类来计算日期是当年的第幾天、当月的第幾天和当周的第幾天。
程序检查日期是否合法，即月份和日期是否在给定的年份范围内。如果日期合法，程序计算两个日期之间的天数、相差月份和相差年份。
最后，程序打印出计算结果或错误消息。

isValidDate 方法使用正则表达式和 ParsePosition 来验证给定的日期是否有效。该方法确保日期遵循 yyyy-MM-dd 的格式，并且年份没有超过 9999 年。它还检查月份和日期是否在给定的范围内。

judge 方法用于检查给定的日期是否合法，即月份和日期是否在给定的年份范围内。它考虑闰年和每个月的天数限制。

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=₅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=₅true
4+6=₂₂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。

本题暂不考虑出现多张答卷的信息的情况。
分析：此次题目难度再次加大导致我仍然未能完成

总结：

采坑心得：有时候会忘记初始化变量，且会忘记某些函数的使用方法导致写题目速度大幅下滑，会忘记题目中的某些条件导致题目卡顿，停滞不前
改进建议：应当多去熟读Java中的函数使用方法，不应该忘记，且写作业要勤快一点，不能浪费太多时间。
通过这几次实验，我学到某些重要的函数使用方法和正则表达式的使用方法，让我坚定把Java学下去的信心

标签：总结,题目,String,int,pta,实验,信息,public,输入
From： https://www.cnblogs.com/lwp111/p/18149785

pta实验总结

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

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103 #A:1-4

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103

相关文章

赞助商

阅读排行