Java面向对象程序设计PTA题目解析二

一、 集体评分

有一个团队由5个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的3个分数的平均分就是该团队对指导老师的评分。

// 导入Arrays和Scanner类，以便使用它们的排序和输入功能  
import java.util.Arrays;  
import java.util.Scanner;  
  
// 定义主类Main，它是程序的入口点  
public class Main {  
    // 主方法，程序的执行从这里开始  
    public static void main(String[] args) {  
        // 创建一个Scanner对象in，用于从标准输入（通常是键盘）读取数据  
        Scanner in = new Scanner(System.in);  
        // 创建一个整型数组grade，用于存储5个分数  
        int[] grade = new int[5];  
        // 使用for循环读取用户输入的5个分数，并存储在grade数组中  
        for (int i = 0; i < grade.length; i++) {  
            // 提示用户输入第i+1个分数（因为i从0开始）  
            System.out.print("请输入第 " + (i + 1) + " 个分数: ");  
            // 读取用户输入的整数，并将其存储在grade数组的第i个位置  
            grade[i] = in.nextInt();  
        }  
  
        // 创建一个RT类的实例rt，传入grade数组作为参数  
        RT rt = new RT(grade); // 修改类名RR为RT，因为RT是实际实现mark()方法的类  
        // 调用rt的mark()方法计算平均分，并将结果存储在double类型的变量dd中  
        double dd = rt.mark();  
        // 使用System.out.printf以两位小数的格式输出平均分  
        System.out.printf("团队对指导老师的评分为: %.2f\n", dd);  
    }  
}  
  
// 定义一个抽象类RR，它有一个整型数组grade作为成员变量  
abstract class RR {  
    int[] grade;  
  
    // RR类的构造函数，用于初始化grade数组  
    public RR(int[] grade) {  
        this.grade = grade;  
    }  
  
    // 定义一个抽象方法mark()，它返回一个double类型的值，但具体实现由子类提供  
    public abstract double mark();  
}  
  
// 定义一个类RT，它继承自RR抽象类  
class RT extends RR {  
    // RT类的构造函数，它调用父类RR的构造函数来初始化grade数组  
    public RT(int[] grade) {  
        super(grade); // 调用父类的构造函数  
    }  
  
    // 重写父类RR的mark()方法，实现计算去掉一个最高分和一个最低分后的平均分的逻辑  
    @Override  
    public double mark() {  
        // 使用Arrays类的sort方法对grade数组进行排序  
        Arrays.sort(grade);  
        // 初始化一个整型变量sum，用于累加去掉最高分和最低分后的分数  
        int sum = 0;  
        // 使用for循环遍历grade数组（跳过第一个和最后一个元素），累加分数  
        for (int i = 1; i < grade.length - 1; i++) {  
            sum += grade[i];  
        }  
        // 返回累加后的分数除以3的结果，即去掉一个最高分和一个最低分后的平均分  
        return (double) sum / 3;  
    }  
}

二、奖学金资格审查系统

由于奖学金评选工作需要，现需要设计一套系统对学生是否具有评选资格进行筛选，目前已给出一个学生类Student，其包含学号（String id）、综合测评成绩（double ca）两个私有属性，以及具有能够初始化学号和综合测评成绩两个参数的构造方法和判断是否具有参评奖学金资格的方法(boolean isReq())，需要您完成以下内容：
1、定义本科生类Undergraduate继承Student，并重写isReq()若ca>=80时返回true,否则返回false;
2、定义研究生类Graduate继承Student，增加导师确认（boolean
supervisor）属性，并重写isReq()若ca>=85且supervisor为true时返回true,否则返回false;
注意：除题目已给出的属性，所有类不得添加新的属性，但可以适当添加方法。
裁判测试程序样例：
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//通过键盘输入确定Student数组的长度
Student[] stu = new Student[Integer.parseInt(sc.nextLine())];
for (int i = 0; i < stu.length; i++) {
//截取输入的字符
String[] str = sc.nextLine().split(“\s+”);
//三个字符串表示为Graduate，否则为Undergraduate
if (str.length > 2) {
stu[i] = new Graduate(str[0], Double.parseDouble(str[1]),
Boolean.parseBoolean(str[2]));
} else {
stu[i] = new Undergraduate(str[0], Double.parseDouble(str[1]));
}
}

    //循环输出结果
    for (int i = 0; i < stu.length; i++) {
      if(stu[i].isReq())
         System.out.println(stu[i].getId() + " pass" );
      else
         System.out.println(stu[i].getId() + " fail" );            
    }

    sc.close();
} }

class Student {
private String id;
private double ca;

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

public boolean isReq() {
    return false;
}

public String getId() {
    return id;
}

public double getCA() {
    return ca;
} }

/* 请在这里填写答案 */
输入样例：
7 001 56 002 80 003 81 004 12 false 005 80 false 006 85 false 007 85
true

输入样例解释：
第1行表示需要输入n行数据；
第2至n+1行表示待输入的学生信息，格式为学号+分数+导师确认（有此项表示为研究生，本科生没有），每个数据间用空格隔开。

输出样例：
001 fail 002 pass 003 pass 004 fail 005 fail 006 fail 007 pass

输出样例解释：
n行结果，格式为学号+结果，每个数据间空格隔开。

// 导入Scanner类，用于从标准输入读取数据  
import java.util.Scanner;  
  
// 定义主类Main  
public class Main {  
    // 主方法，程序的入口点  
    public static void main(String[] args) {  
        // 创建Scanner对象，用于读取标准输入  
        Scanner sc = new Scanner(System.in);  
        // 通过键盘输入确定Student数组的长度  
        int n = Integer.parseInt(sc.nextLine()); // 注意：这里我修改了变量名为n，以更清晰地表示它是一个整数  
        Student[] stu = new Student[n]; // 创建一个Student类型的数组，长度为n  
  
        // 循环读取每个学生的信息  
        for (int i = 0; i < stu.length; i++) {  
            // 截取输入的字符，按空格分割  
            String[] str = sc.nextLine().split("\\s+");  
            // 如果输入包含三个或更多部分，则认为是Graduate  
            if (str.length > 2) {  
                stu[i] = new Graduate(str[0], Double.parseDouble(str[1]),  
                        Boolean.parseBoolean(str[2])); // 创建Graduate对象并添加到数组中  
            } else {  
                // 否则，认为是Undergraduate  
                stu[i] = new Undergraduate(str[0], Double.parseDouble(str[1])); // 创建Undergraduate对象并添加到数组中  
            }  
        }  
  
        // 循环输出结果  
        for (int i = 0; i < stu.length; i++) {  
            // 根据isReq()方法的返回值判断学生是否通过  
            if (stu[i].isReq())  
                System.out.println(stu[i].getId() + " pass"); // 如果通过，则输出学号+pass  
            else  
                System.out.println(stu[i].getId() + " fail"); // 如果未通过，则输出学号+fail  
        }  
  
        // 关闭Scanner对象  
        sc.close();  
    }  
}  
  
// 定义Student类，作为Undergraduate和Graduate的基类  
class Student {  
    // 定义私有成员变量id和ca  
    private String id;  
    private double ca;  
  
    // 构造函数，用于初始化Student对象  
    public Student(String id, double ca) {  
        this.id = id;  
        this.ca = ca;  
    }  
  
    // isReq()方法的默认实现，子类需要重写  
    public boolean isReq() {  
        return false; // 默认返回false，表示不满足要求  
    }  
  
    // getId()方法，用于获取学生的学号  
    public String getId() {  
        return id;  
    }  
  
    // getCA()方法，用于获取学生的综合测评成绩  
    public double getCA() {  
        return ca;  
    }  
}  
  
// 定义Undergraduate类，继承自Student类  
class Undergraduate extends Student {  
    // 构造函数，调用父类的构造函数进行初始化  
    public Undergraduate(String id, double ca) {  
        super(id, ca);  
    }  
  
    // 重写isReq()方法，根据综合测评成绩判断是否通过  
    @Override  
    public boolean isReq() {  
        return this.getCA() >= 80; // 如果综合测评成绩大于等于80，则通过  
    }  
}  
  
// 定义Graduate类，继承自Student类  
class Graduate extends Student {  
    // 定义私有成员变量supervisor，表示导师是否确认  
    private boolean supervisor;  
  
    // 构造函数，调用父类的构造函数进行初始化，并设置导师确认状态  
    public Graduate(String id, double ca, boolean supervisor) {  
        super(id, ca);  
        this.supervisor = supervisor;  
    }  
  
    // 重写isReq()方法，根据综合测评成绩和导师确认状态判断是否通过  
    @Override  
    public boolean isReq() {  
        return this.getCA() >= 85 && this.supervisor; // 如果综合测评成绩大于等于85且导师确认，则通过  
    }  
  
    // 可选：获取导师确认状态的方法  
    public boolean isSupervisor() {  
        return supervisor;  
    }  
}

这段代码中，Undergraduate类继承了Student类，并重写了isReq()方法，使其在学生综合测评成绩（ca）大于或等于80时返回true。类似地，Graduate类也继承了Student类，并增加了supervisor属性（虽然按照题目要求不能直接添加新属性，但这里因为是研究生特有的属性，所以例外添加），同时重写了isReq()方法，使其在学生综合测评成绩大于或等于85且导师确认为true时返回true。
请注意，由于Graduate类需要处理导师确认的状态，因此它在构造函数中额外接收了一个boolean类型的参数来初始化supervisor属性。同时，我提供了一个可选的isSupervisor()方法，以便在需要时检查导师的确认状态，但这个方法不是题目要求的必要部分。

三、设计一个Triangle类继承自GeometricObject类

设计一个名为Triangle的类来扩展GeometricObject类。该类包括： ■
三个名为side1、side2和side3的double数据域表示这个三角形的三条边，它们的默认值是1.0。

■ 一个无参构造方法创建默认的三角形。

■ 一个能创建带制定side1、side2和side3的三角形的构造方法。

■ 所有三个数据域的访问器方法。

■ 一个名为getArea()的方法返回这个三角形的面积。

■ 一个名为getPerimeter()的方法返回这个三角形的周长。

■ 一个名为toString()的方法返回这个三角形的字符串描述。

toString()方法的实现如下所示：

return “Triangle: side1 = " + side1 + " side2 = " + side2 +” side3 = "+ side3;

编写一个测试程序，提示用户输入三角形的三条边、颜色以及一个Boolean值表明该三角形是否填充。程序应该使用输入创建一个具有这些边并设置color和filled属性的三角形。程序应该显示面积、周长以及边长。

系统会自动提交Main类和GeometricObject类。

类的定义：

设计一个Triangle类继承GeometricObject。例如：
class Triangle extends GeometricObject{  }

裁判测试程序样例：

//Main测试类
public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        double side1 = input.nextDouble();
        double side2 = input.nextDouble();
        double side3 = input.nextDouble();

        Triangle triangle = new Triangle(side1, side2, side3);

        String color = input.next();
        triangle.setColor(color);

        boolean filled = input.nextBoolean();
        triangle.setFilled(filled);

        System.out.println("The area is " + triangle.getArea());
        System.out.println("The perimeter is "
                + triangle.getPerimeter());
        System.out.println(triangle);
    }
}

//GeometricObject类
class GeometricObject {
    private String color = "white";
    private boolean filled;
    private java.util.Date dateCreated;

    public GeometricObject() {
        dateCreated = new java.util.Date();
    }

    public GeometricObject(String color, boolean filled) {
        dateCreated = new java.util.Date();
        this.color = color;
        this.filled = filled;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public boolean isFilled() {
        return filled;
    }

    public void setFilled(boolean filled) {
        this.filled = filled;
    }

    public java.util.Date getDateCreated() {
        return dateCreated;
    }
    

    @Override
    public String toString() {
        return "created on " + dateCreated + "\ncolor: " + color + "and filled: " + filled;
    }

}
/* 请在这里填写答案 */

输入样例：

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

3 4 5 red true

输出样例：

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

The area is 6.0 The perimeter is 12.0 Triangle: side1=3.0 side2=4.0
side3=5.0

class Triangle extends GeometricObject{
    private double side1 = 1.0;
    private double side2 = 1.0;
    private double side3 = 1.0;
    
    public Triangle(double side1, double side2, double side3) {
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

    private double s() {
        return (side1 + side2 + side3)/2;
    }

    public double getArea() {
        double s = s();
        return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));
    }

    public double getPerimeter() {
        return side1 + side2 + side3;
    }

    public String toString() {
        return "Triangle: side1=" + side1 + " side2=" + side2 + " side3=" + side3;
    }
}

四、设计BankAccount类

设计一个BankAccount类，这个类包括： （1）一个int型的balance表时账户余额。

（2）一个无参构造方法，将账户余额初始化为0。

（3）一个带一个参数的构造方法，将账户余额初始化为该输入的参数。

（4）一个getBlance（）方法，返回账户余额。

（5）一个withdraw（）方法：带一个amount参数，并从账户余额中提取amount指定的款额。

（6）一个deposit（）方法：带一个amount参数，并将amount指定的款额存储到该银行账户上。

提供main函数，构造一个账户对象，并对其进行存取款操作。

其中操作类型类型为1表示存款，2表示取款，每次操作后都打印余额

输入格式:

账户余额 操作个数 操作类型 操作金额

输出格式:

每次操作后的余额

输入样例:

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

0
4
1 100
1 200
2 100
2 100

输出样例:

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

100
300
200
100

import java.util.Scanner; // 导入Scanner类，用于从控制台读取输入  
  
class BankAccount // 定义一个名为BankAccount的类  
{  
    int balance; // 定义一个整型变量balance，用于存储账户余额  
  
    // 构造方法1：无参构造方法，初始化balance为0  
    public BankAccount(){  
        this.balance= 0;  
    }  
  
    // 构造方法2：带有一个整型参数的构造方法，用于初始化balance  
    public BankAccount(int t){  
        this.balance= t;  
    }  
  
    // 获取balance的方法  
    public int getBalance(){  
        return this.balance;  
    }  
  
    // 取款方法，参数x表示取款金额  
    public void withdraw(int x){  
        if(this.balance>=x) // 如果账户余额大于等于取款金额  
            this.balance -= x; // 则从balance中减去取款金额  
        else  
            ; // 否则不执行任何操作（这里可以添加一条错误消息）  
    }  
  
    // 存款方法，参数x表示存款金额  
    public void deposit(int x) {  
        this.balance += x; // 将存款金额加到balance上  
    }  
  
    // 打印余额的方法  
    public void print()  
    {  
        System.out.println(balance); // 打印当前balance的值  
    }  
}  
  
public class Main // 定义一个名为Main的公共类  
{  
    public static void main(String[] args) { // 主方法，程序的入口点  
        Scanner sc= new Scanner(System.in); // 创建一个Scanner对象，用于从控制台读取输入  
  
        // 输入初始余额  
        int t=sc.nextInt(); // 从控制台读取一个整数，作为账户的初始余额  
  
        // 创建账户对象，使用初始余额t作为参数  
        BankAccount p = new BankAccount(t);  
  
        // 输入交易循环的次数  
        int cycle= sc.nextInt(); // 从控制台读取一个整数，表示将要进行的交易次数  
  
        // 循环执行交易操作  
        for(int i=0;i<cycle;i++)  
        {  
            // 从控制台读取一个整数，判断是存款还是取款操作  
            if(sc.nextInt()==1) // 如果输入的整数是1，表示进行存款操作  
                p.deposit(sc.nextInt()); // 从控制台读取存款金额，并调用deposit方法存款  
            else // 否则，表示进行取款操作  
                p.withdraw(sc.nextInt()); // 从控制台读取取款金额，并调用withdraw方法取款  
  
            // 打印当前余额  
            p.print(); // 调用print方法打印当前账户的余额  
        }  
    }  
}

五、静态变量统计

声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组(最多10个元素），并求出总册数。

输入格式:

请输入每本图书对应的书名，书价（最多10本）

输出格式:

请输出每本图书对应的书名，书号，书价以及总图书数。

输入样例:

在这里给出一组输入（以空格分隔）。例如：

Java程序设计 34.5 数据结构 44.8 C++程序设计 35.0

输出样例:

在这里给出相应的输出（英文标点符号，中间无空格）。例如：
书名:Java程序设计,书号:1,书价:34.5
书名:数据结构,书号:2,书价:44.8
书名:C++程序设计,书号:3,书价:35.0
图书总册数为:3

import java.util.Scanner;
 
class Book {
    String name;
    int order;
    float price;
    static int total = 0; // 静态变量记录图书总册数
 
    public Book(String name, float price) {
        this.name = name;
        this.price = price;
        this.order = ++total; // 自动编号
    }
 
    public void display() {
        System.out.println("书名:" + name + ",书号:" + order + ",书价:" + price);
    }
}
 
public class Main {
    public static void main(String[] args) {
        Book[] books = new Book[10]; // 定义最多10个图书对象的数组
        Scanner sc = new Scanner(System.in);
        int t = 0;
 
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            
            String[] parts = line.split(" ");
            if (parts.length != 2) {
                break;
            }
            String name = parts[0];
            float price = Float.parseFloat(parts[1]);
            books[t] = new Book(name, price); // 创建 Book 对象并添加到数组中
            books[t].display();
            t++;
        }
        System.out.println("图书总册数为:" + Book.total); // 输出图书总册数
    }