剛開始接觸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學下去的信心

posted on 2024-04-21 23:39 23201621龍文平閱讀(189) 評論(0) 收藏舉報

刷新頁面返回頂部