JAVA面向对象程序设计基础期末复习

复习目标：

查漏补缺：参考PTA2024练习题集

---

复习内容：

一、程序填空题

1、使用this调用已有的有参构造方法

在Java中，使用this关键字调用同一个类中的另一个构造方法（也称为构造器重载或构造器链）是一种常见的做法。这允许你在一个构造方法中复用另一个构造方法的代码。

public class Rectangle {
    private int width;
    private int length;

    // 无参构造方法，使用this调用有参构造方法
    public Rectangle() {
        this(5, 6); // 调用有参构造方法，设置width为5，length为6
    }

    // 有参构造方法
    public Rectangle(int width, int length) {
        this.width = width; // 将参数width赋值给成员变量width
        this.length = length; // 将参数length赋值给成员变量length
    }

    // Getter和Setter方法（可选）
    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    // 覆盖toString方法
    @Override
    public String toString() {
        return "width=" + width + ", length=" + length;
    }

    // 示例main方法，用于测试
    public static void main(String[] args) {
        Rectangle rect1 = new Rectangle(); // 使用无参构造方法
        Rectangle rect2 = new Rectangle(10, 20); // 使用有参构造方法

        System.out.println(rect1); // 输出: width=5, length=6，因为调用了toString方法
        System.out.println(rect2); // 输出: width=10, length=20，因为调用了toString方法
    }
}

在这个例子中，this(5, 6);在无参构造方法中的使用是正确的，它确保了当你创建一个没有参数的Rectangle对象时，它的width和length会被设置为5和6。这是通过调用有参构造方法来实现的，该方法接收两个整数参数并将它们分别赋值给类的成员变量。
注意，使用this调用构造方法必须是构造方法中的第一条语句。这是Java语言的一个规定，因为如果先执行了其他语句，那么构造方法的初始化逻辑可能已经被部分执行，这可能会导致不一致的状态或错误。

2、多线程-守护线程

为了确保主线程退出时，在 main 方法中所启动的线程 t1 也要自动结束，需要将 t1 线程设置为守护线程（Daemon Thread）。守护线程是一种特殊的线程，它的生命周期依赖于非守护线程（即用户线程）。当所有非守护线程结束时，JVM 会自动退出，并且不会管守护线程是否还在运行。但是，反过来，如果希望当主线程（非守护线程）退出时，守护线程也随之结束，那么就需要将线程设置为守护线程。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new PrintTask());
        
        // 将 t1 设置为守护线程
        t1.setDaemon(true);
        
        // 启动 t1 线程
        t1.start();
        
        // 主线程休眠一段时间以观察守护线程的行为
        // 注意：这里只是为了演示，实际使用中不需要这样做
        Thread.sleep(2000);
        
        // 主线程结束
        System.out.println(Thread.currentThread().getName() + " end");
        
        // 注意：当主线程结束时，由于 t1 是守护线程，它会自动结束，
        // 不需要在这里显式地等待 t1 结束，因为守护线程会随着 JVM 的退出而退出。
        // 但是，为了观察效果，上面的 Thread.sleep(2000) 允许守护线程运行一段时间。
    }
}

class PrintTask implements Runnable {
    @Override
    public void run() {
        // 模拟打印任务
        while (true) { // 守护线程通常会运行一个无限循环，直到 JVM 退出
            System.out.println(Thread.currentThread().getName() + " is printing");
            try {
                // 模拟任务耗时
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // 如果守护线程被中断，它通常会选择退出循环并结束
                Thread.currentThread().interrupt(); // 恢复中断状态，尽管在这个例子中可能不需要
                break; // 退出循环，结束线程
            }
        }
        System.out.println(Thread.currentThread().getName() + " finished printing (but this won't be reached if the JVM exits first)");
        // 注意：上面的打印语句在实际情况下可能不会被执行，因为 JVM 可能会在打印之前退出。
    }
}

3、多线程-线程等待

为了确保 t1 线程打印完后，才执行主线程 main 方法的最后一句 System.out.println(Thread.currentThread().getName()+" end");，你需要确保主线程等待 t1 线程完成其任务。这可以通过调用 t1.join() 方法来实现。join() 方法会使当前线程（在这个例子中是主线程）等待，直到调用 join() 的线程（在这个例子中是 t1）终止。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new PrintTask());
        
        // 启动 t1 线程
        t1.start();
        
        // 等待 t1 线程完成
        t1.join();
        
        // 确保 t1 线程打印完后才执行这一句
        System.out.println(Thread.currentThread().getName()+" end");
    }
}

class PrintTask implements Runnable {
    @Override
    public void run() {
        // 模拟打印任务
        System.out.println(Thread.currentThread().getName() + " is printing");
        // 你可以在这里添加更多的打印逻辑或任务
        try {
            // 模拟任务耗时
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println(Thread.currentThread().getName() + " finished printing");
    }
}

4、普通账户和支票账户

编写一个Java程序，包含类Acount、CheckingAccount、Main，其中Main已经实现，请你编写Acount和CheckingAccount类。
(1)编写一个类Account表示普通账户对象，包含以下成员
①属性：
id：私有，int型，表示账户编号；
balance：私有，int型，表示账户余额；
②方法：
Account(), 构造方法，id和balance都初始化为0；
Account(int id，int balance)，构造方法，用参数设置账户编号和余额；
void setBalance(int balance):修改账户金额
int getBalance():返回账户金额
boolean withdraw(int money)：从账户提取特定数额，如果余额不足，返回false；否则，修改余额，返回true；
void deposit(int money)：向账户存储特定数额。
public String toString():将把当前账户对象的信息转换成字符串形式，例如id为123，余额为1000,返回字符串"The balance of account 123 is 1000"。
(2)编写一个Account类的子类CheckingAccount，表示支票账户对象，包含以下成员
①属性：
overdraft：私有，int型，表示透支限定额；
②方法：
CheckingAccount(), 构造方法，id、balance和overdraft都初始化为0；
CheckingAccount(int id，int balance，int overdraft)，构造方法，用参数设置账户编号、余额和透支限定额；
boolean withdraw(int money)：从账户提取特定数额，如果超出透支限定额，返回false；否则，修改余额，返回true；
(3)编写公共类Main,实现如下功能
根据用户输入的两个整数id和balance创建普通账户a；
输入一个整数n，表示对账户a有n笔操作；
每笔操作输入一个字符串和一个整数money（表示操作金额）
如果字符串为“withdraw”表示取现操作，如果操作成功,输出“withdraw ” + money + “success”，否则输出“withdraw ” + money + “failed”
如果字符串为“deposit”表示存入操作，完成操作后输出“deposit” + money + “success”
使用toString方法输出账户a信息。
根据用户输入的三个整数id、balance和overdraft创建支票账户b；
输入一个整数m，表示对账户b有m笔操作；
每笔操作输入一个字符串和一个整数money（表示操作金额）
如果字符串为“withdraw”表示取现操作，如果操作成功,输出“withdraw ” + money + “success”，否则输出“withdraw ” + money + “failed”
如果字符串为“deposit”表示存入操作，完成操作后输出“deposit” + money + “success”
使用toString方法输出账户b信息。

import java.util.Scanner;

class Account {
    private int id;
    private int balance;

    public Account() {
        id = 0;
        balance = 0;
    }

    public Account(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public boolean withdraw(int money) {
        if (balance < money) {
            return false;
        } else {
            balance -= money;
            return true;
        }
    }

    public void deposit(int money) {
        balance += money;
    }

    public String toString() {
        return "The balance of account " + id + " is " + balance;
    }
}

class CheckingAccount extends Account {
    private int overdraft;

    public CheckingAccount() {
       super();
        this.overdraft = 0;
    }

    public CheckingAccount(int id, int balance, int overdraft) {
        super(id, balance);
        this.overdraft = overdraft;
    }

    @Override
    public boolean withdraw(int money) {
        if (this.getBalance() + overdraft >= money) {
            this.setBalance(this.getBalance() - money);
            return true;
        }
        return false;
    }

    // 继承自Account类的deposit方法，无需重写
    // public void deposit(int money) {
    //     super.deposit(money);
    // }
    // 但由于deposit方法没有使用到overdraft属性，且Account类中已有实现，因此无需在CheckingAccount中重写。

    @Override
    public String toString() {
        return "The balance of checking account " + id + " is " + balance + " (overdraft limit: " + overdraft + ")";
    }
}

public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int n, m;

        // 创建普通账户a
        Account a = new Account(input.nextInt(), input.nextInt());
        n = input.nextInt();
        for (int i = 0; i < n; i++) {
            String op = input.next();
            int money = input.nextInt();
            if (op.equals("withdraw")) {
                if (a.withdraw(money)) {
                    System.out.println("withdraw " + money + " success");
                } else {
                    System.out.println("withdraw " + money + " failed");
                }
            } else if (op.equals("deposit")) {
                a.deposit(money);
                System.out.println("deposit " + money + " success");
            }
        }
        System.out.println(a.toString());

        // 创建支票账户b
        CheckingAccount b = new CheckingAccount(input.nextInt(), input.nextInt(), input.nextInt());
        m = input.nextInt();
        for (int i = 0; i < m; i++) {
            String op = input.next();
            int money = input.nextInt();
            if (op.equals("withdraw")) {
                if (b.withdraw(money)) {
                    System.out.println("withdraw " + money + " success");
                } else {
                    System.out.println("withdraw " + money + " failed");
                }
            } else if (op.equals("deposit")) {
                b.deposit(money);
                System.out.println("deposit " + money + " success");
            }
        }
        System.out.println(b.toString());

        input.close(); // 关闭Scanner以释放资源
    }
}

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

设计一个名为Triangle的类来扩展GeometricObject类。该类包括：
三个名为side1、side2和side3的double数据域表示这个三角形的三条边，它们的默认值是1.0。
一个无参构造方法创建默认的三角形。
一个能创建带制定side1、side2和side3的三角形的构造方法。
所有三个数据域的访问器方法。
一个名为getArea()的方法返回这个三角形的面积。
一个名为getPerimeter()的方法返回这个三角形的周长。
一个名为toString()的方法返回这个三角形的字符串描述，返回的信息包括三角形的颜色、是否填充和三条边的边长。
编写一个测试程序，提示用户输入三角形的三条边、颜色以及一个boolean值表明该三角形是否填充。
程序应该使用输入创建一个具有这些边并设置color和filled属性的三角形。程序应该显示面积、边长、颜色以及表明是否填充的真或者假的值。

import java.util.Scanner;
import java.util.Date;

class GeometricObject {
    private String color = "white";
    private boolean filled;
    private Date dateCreated;

    // 无参构造方法
    public GeometricObject() {
        dateCreated = new Date();
    }

    // 带参数的构造方法
    public GeometricObject(String color, boolean filled) {
        dateCreated = new 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 Date getDateCreated() {
        return dateCreated;
    }

    // 返回对象的字符串描述
    @Override
    public String toString() {
        return "color: " + color + " and filled: " + (filled ? "true" : "false");
    }
}

class Triangle extends GeometricObject {
    private double side1, side2, side3;

    // 无参构造方法，创建默认三角形
    public Triangle() {
        super();
        side1 = 1.0;
        side2 = 1.0;
        side3 = 1.0;
    }

    // 带参数的构造方法，创建指定边长的三角形
    public Triangle(double side1, double side2, double side3) {
        super(); // 可以根据需要传递颜色和填充状态，但这里我们默认使用super()无参构造
        if (isValidTriangle(side1, side2, side3)) {
            this.side1 = side1;
            this.side2 = side2;
            this.side3 = side3;
        } else {
            throw new IllegalArgumentException("Invalid triangle sides");
        }
    }

    // 验证是否为有效的三角形（两边之和大于第三边）
    private boolean isValidTriangle(double a, double b, double c) {
        return (a + b > c) && (a + c > b) && (b + c > a);
    }

    // 获取side1
    public double getSide1() {
        return side1;
    }

    // 获取side2
    public double getSide2() {
        return side2;
    }

    // 获取side3
    public double getSide3() {
        return side3;
    }

    // 计算并返回三角形的面积（使用海伦公式）
    public double getArea() {
        double s = (side1 + side2 + side3) / 2;
        return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
    }

    // 计算并返回三角形的周长
    public double getPerimeter() {
        return side1 + side2 + side3;
    }

    // 返回三角形的字符串描述
    @Override
    public String toString() {
        return super.toString() + "\nTriangle: side1=" + side1 + " side2=" + side2 + " side3=" + side3;
    }
}

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

        System.out.print("Enter the length of side 1: ");
        double side1 = input.nextDouble();
        System.out.print("Enter the length of side 2: ");
        double side2 = input.nextDouble();
        System.out.print("Enter the length of side 3: ");
        double side3 = input.nextDouble();

        System.out.print("Enter the color (e.g., red, blue): ");
        String color = input.next();
        System.out.print("Is the triangle filled? (true/false): ");
        boolean filled = input.nextBoolean();

        Triangle triangle = new Triangle(side1, side2, side3);
        triangle.setColor(color);
        triangle.setFilled(filled);

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

        input.close();
    }
}

6、House类

构造一个House类表示住宅 ， 该类实现了Comparable接口。
该类有一个私有的String类型成员变量address，两个私有的double型成员变量area和pirce；
该类有一个带一个String型参数和两个double型参数的构造方法，用参数的值初始化house对象。
为address、area和price添加getter()和setter()方法。注意，住宅的面积和价格必须大于0，如果setArea(double area)方法的参数小于等于0时，抛出一个IllegalArgumentException异常对象，异常对象的成员变量message为"住宅的面积必须大于0"；如果setPrice(double price)方法的参数小于等于0时，抛出一个IllegalArgumentException异常对象，异常对象的成员变量message为"住宅的价格必须大于0"。
该类有一个公共的方法int compareTo(House house)，比较的依据是住宅的单位均价（价格除以面积）。如果当前对象的单位均价大于参数的单位均价，返回1；当前对象的单位均价小于参数的单位均价，返回-1；否则返回0。
该类有一个公共方法toString()，根据住宅的数据生成并返回一个字符串（具体要求看输出样例）。
构造一个Main ，执行一个for循环，共循环10次。每次循环从键盘读入数据创建两个House对象，比较并输出其中较大的对象；如果捕捉到异常，则输出异常信息。

输入样例
杭州1号 0 1000000 杭州2号 50 600000
杭州1号 -1 1000000 杭州2号 50 600000
杭州1号 100 0 杭州2号 50 600000
杭州1号 100 -1 杭州2号 50 600000
杭州1号 100 1000000 杭州2号 0 600000
杭州1号 100 1000000 杭州2号 -1 600000
杭州1号 100 1000000 杭州2号 50 0
杭州1号 100 1000000 杭州2号 50 -1
杭州1号 100 1000000 杭州2号 50 600000
杭州1号 100 2000000 杭州2号 50 600000

输出样例
住宅的面积必须大于0
住宅的面积必须大于0
住宅的价格必须大于0
住宅的价格必须大于0
住宅的面积必须大于0
住宅的面积必须大于0
住宅的价格必须大于0
住宅的价格必须大于0
The max of House{address=杭州1号, area=100.0, price=1000000.0} and House{address=杭州2号, area=50.0, price=600000.0} is House{address=杭州2号, area=50.0, price=600000.0}
The max of House{address=杭州1号, area=100.0, price=2000000.0} and House{address=杭州2号, area=50.0, price=600000.0} is House{address=杭州1号, area=100.0, price=2000000.0}

import java.util.Scanner;

// House类实现了Comparable接口，用于比较两个House对象
class House implements Comparable<House> {
    private String address;
    private double area;
    private double price;

    // 构造方法，初始化House对象
    public House(String address, double area, double price) {
        this.address = address;
        setArea(area); // 使用setArea方法来设置面积，以便进行验证
        setPrice(price); // 使用setPrice方法来设置价格，以便进行验证
    }

    // getter方法
    public String getAddress() {
        return address;
    }

    // setter方法，带验证
    public void setAddress(String address) {
        this.address = address;
    }

    // getter方法
    public double getArea() {
        return area;
    }

    // setter方法，验证面积是否大于0
    public void setArea(double area) {
        if (area > 0) {
            this.area = area;
        } else {
            throw new IllegalArgumentException("住宅的面积必须大于0");
        }
    }

    // getter方法
    public double getPrice() {
        return price;
    }

    // setter方法，验证价格是否大于0
    public void setPrice(double price) {
        if (price > 0) {
            this.price = price;
        } else {
            throw new IllegalArgumentException("住宅的价格必须大于0");
        }
    }

    // compareTo方法，根据单位均价比较两个House对象
    @Override
    public int compareTo(House o) {
        double thisUnitPrice = this.price / this.area;
        double otherUnitPrice = o.price / o.area;
        if (thisUnitPrice > otherUnitPrice) {
            return 1;
        } else if (thisUnitPrice < otherUnitPrice) {
            return -1;
        } else {
            return 0;
        }
    }

    // toString方法，返回House对象的字符串表示
    @Override
    public String toString() {
        return "House{address=" + address + ", area=" + area + ", price=" + price + "}";
    }
}

// Main类，包含main方法，用于执行程序
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 循环10次，每次从键盘读取数据并创建两个House对象进行比较
        for (int i = 0; i < 10; i++) {
            try {
                // 读取数据并创建House对象
                String address1 = input.next();
                input.nextLine(); // 消耗换行符
                double area1 = input.nextDouble();
                double price1 = input.nextDouble();
                input.nextLine(); // 消耗换行符

                String address2 = input.next();
                input.nextLine(); // 消耗换行符
                double area2 = input.nextDouble();
                double price2 = input.nextDouble();
                input.nextLine(); // 消耗换行符

                House house1 = new House(address1, area1, price1);
                House house2 = new House(address2, area2, price2);

                // 比较两个House对象并输出较大的一个
                House maxHouse = (house1.compareTo(house2) >= 0) ? house1 : house2;
                System.out.println("The max of " + house1 + " and " + house2 + " is " + maxHouse);
            } catch (IllegalArgumentException e) {
                // 捕捉IllegalArgumentException并输出异常信息
                System.out.println(e.getMessage());
                input.nextLine(); // 消耗可能的剩余输入
            } catch (Exception e) {
                // 捕捉其他异常并输出异常信息
                System.out.println("An unexpected error occurred: " + e.getMessage());
                input.nextLine(); // 消耗可能的剩余输入
            }
        }

        // 关闭Scanner对象
        input.close();
    }
}

7、sdut-oop-1-测试对象初始化（构造方法）

public class Main {
    public static void main(String[] args) {
        Test test = new Test(true);
    }
}

class Test {
    public Test(){
        System.out.println("Constructor one invoked!");
    }
    public Test(int x){
        this();
        System.out.println("Constructor two invoked!");
    }
    public Test(boolean b){
        this(1);
        System.out.println("Constructor three invoked!");
    }
    
}

Constructor one invoked!
Constructor two invoked!
Constructor three invoked!

8、设计一个square类

设计一个名为Square的正方形类。该类包括：
（1）一个名为side的double成员变量，表示这个正方形的边长。
（2）一个无参构造方法，将正方形的边长设置为默认值1.0。
（3）一个带参数的构造方法，参数列表为“double side”,用这个参数的值初始化正方形的边长。
（4）成员变量side的get方法和set方法。
（5）一个名为getArea()的方法返回这个正方形的面积。
（6） 一个名为toString()的方法返回这个正方形的字符串描述。如边长分别为1.0，则返回字符串“Square: side=1.0 area=1.0”。
（7）设计一个测试程序，输入边长x，输出正方形的描述。如输入为3.0，则输出为：Square: side=3.0 area=9.0
所有的成员变量都为私有变量，所有的成员方法都为公共方法。
运行该程序，当输入10时，输出为：
Square: side=10.0 area=100.0
根据设计要求用Java语言编写程序，在以下空格处填上合适的内容：

import java.util.Scanner;

class Square {
    private double side; // 成员变量side，表示正方形的边长

    public Square() {
        side = 1.0; // 无参构造方法，将边长设置为默认值1.0
    }

    public Square(double side) { // 带参数的构造方法
        this.side = side; // 使用this关键字来区分成员变量和参数变量
    }

    public double getSide() { // get方法返回side的值
        return side;
    }

    public void setSide(double side) { // set方法设置side的值
        this.side = side;
    }

    public double getArea() { // 计算并返回正方形的面积
        return side * side;
    }

    public String toString() { // 返回正方形的字符串描述
        return "Square: side=" + side + " area=" + getArea();
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in); // 创建Scanner对象以读取用户输入
        double x = input.nextDouble(); // 读取用户输入的边长
        Square s = new Square(x); // 使用带参数的构造方法创建Square对象
        System.out.println(s.toString()); // 输出正方形的描述
    }
}

9、继承和异常处理顺序示例

现有一个Employee类，继承了Person类，其中Employee类有一个年龄age属性，当年龄为负数时会发生异常。根据运行结果，补充以下程序空格处代码：

class Person {
    public Person() {
        System.out.println("创建一个Person");
    }
}

class Employee extends Person {
    private int age;

    public Employee(int age) {
        super(); // 调用父类的构造方法
        setAge(age);
    }

    public void setAge(int age) throws IllegalArgumentException {
        if (age >= 0)
            this.age = age;
        else
            throw new IllegalArgumentException("年龄不能为负数");
    }

    // 可以添加一个方法来显示员工的年龄（可选）
    public void displayAge() {
        System.out.println("年龄为：" + age);
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("开始创建员工...");
            Employee emp1 = new Employee(10);
            emp1.displayAge(); // 显示emp1的年龄

            System.out.println("继续创建员工...");
            Employee emp2 = new Employee(-1); // 这行代码将抛出异常
        } catch (IllegalArgumentException ex) {
            System.out.println(ex.getMessage());
        } finally {
            System.out.println("继续.....");
        }

        System.out.println("任务完成！");
    }
}

创建一个Person
创建了一个Employee
年龄为：10
创建一个Person
创建了一个Employee
年龄不能为负数
继续…
任务完成！

10 、输入圆的半径，打印它的周长和面积。

输入圆的半径，打印它的周长和面积。
要求：
（1）创建类Circle表示圆这种图形。
（2）周长和面积各保留2位小数，中间用1个空格分开。如果半径小于0，不能构成Circle类的对象，周长和面积均为0.00。
（圆周率利用：Math.PI 来表示。）

import java.util.Scanner;

class Circle {
    private double r; // 圆的半径

    // 构造方法，用于初始化半径
    // 注意：若半径小于0，我们在此不抛出异常，而是简单地将半径设为0（根据题目要求）
    public Circle(double r) {
        if (r < 0) {
            this.r = 0; // 若半径非法，则设为0
        } else {
            this.r = r;
        }
    }

    // 计算周长的方法
    public double length() {
        return 2 * Math.PI * r;
    }

    // 计算面积的方法
    public double area() {
        return Math.PI * r * r;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入圆的半径：");
        double radius = input.nextDouble();

        // 创建Circle对象
        Circle circle = new Circle(radius);

        // 计算周长和面积，并格式化输出，保留两位小数
        String result = String.format("%.2f %.2f", circle.length(), circle.area());
        System.out.println(result);

        // 关闭Scanner
        input.close();
    }
}

11、输入长方形的长和宽，打印它的周长和面积

输入长方形的长和宽，打印它的周长和面积。要求：中间用1个空格分开。
创建类Rectangle类表示长方形这种图形。
如果长或宽的值小于0，则不能构成Rectangle类的对象，周长和面积均为0。

import java.util.Scanner;

class Rectangle {
    int a, b;

    // 默认构造器
    public Rectangle() {
        this.a = 0;
        this.b = 0;
    }
    
    // 带参数的构造器，进行有效性检查
    public Rectangle(int a, int b) {
        if (a < 0 || b < 0) {
            this.a = 0;
            this.b = 0;
        } else {
            this.a = a;
            this.b = b;
        }
    }

    public int getA() {
        return a;
    }

    // Setter 方法，这里不需要进行额外的有效性检查，因为主逻辑已经在构造器中处理了
    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    // 计算周长的方法
    public int length() {
        return 2 * (a + b);
    }

    // 计算面积的方法
    public int area() {
        return a * b;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        
        // 输入第一组长和宽
        int a = input.nextInt(); 
        int b = input.nextInt();
        Rectangle rect1 = new Rectangle(a, b); // 使用构造器进行有效性检查
        System.out.println(rect1.length() + " " + rect1.area());
        
        // 输入第二组长和宽
        int c = input.nextInt();
        int d = input.nextInt();
        Rectangle rect2 = new Rectangle(); // 使用默认构造器
        rect2.setA(c);
        rect2.setB(d);
        // 注意：这里 rect2 的长和宽没有进行有效性检查，因为 setA 和 setB 方法中没有进行检查
        // 如果需要在这里也进行检查，可以在 setA 和 setB 中加入逻辑，或者重新构造一个方法进行检查和设置
        System.out.println(rect2.length() + " " + rect2.area());
    }
}

12、读取学生信息，按要求的格式打印出来（构造方法和toString方法）

读取学生信息，按要求打印出来。
输入有若干行，每行的格式为：学号、姓名、年龄，中间有空格分隔。
1 Kate 20
每行输入，对应一行输出。输出格式：
Student [id=1, name=Kate, age=20]

import java.util.Scanner;

class Student {
    int id;  // 学号
    String name;  // 姓名
    int age;  // 年龄

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int id;
        String name;
        int age;
        Student stu;

        // 假设输入会在某时刻结束，例如输入EOF（Ctrl+D在Unix/Linux/Mac，Ctrl+Z在Windows）
        while (sc.hasNext()) {
            id = sc.nextInt();
            name = sc.next();
            age = sc.nextInt();
            stu = new Student(id, name, age);
            System.out.println(stu);
        }

        sc.close();
    }
}

13、Car

构造一个Vehicle类，表示交通工具。该类包含如下成员：
私有的int类型成员变量speed，表示当前时速（单位为公里每小时，不能是负数）。
带一个int型参数的构造方法，参数用来初始化当前时速的值（如果参数小于0，则将当前时速设为0）。
为speed添加getter()和setter()方法。注意setSpeed(int speed)方法的参数小于0时，将当前时速设为0。
构造一个Car类表示汽车 ， 该类继承至Vehicle类。该类包含如下成员：
私有的double类型成员变量distance，表示汽车的已行驶里程；
带一个int型参数的构造方法，用参数的值初始化speed的值，distance设为0。
带一个double型参数的构造方法，用参数的值初始化distance的值，speed设为0。
带一个int型和一个double型参数的构造方法，用参数分别初始化speed和distance的值。
public void increaseSpeed (int differenceInc)方法，将汽车的当前时速增加differenceInc。
public void decreaseSpeed (int differenceDec)方法，将汽车的当前时速降低differenceDec（汽车的当前时速不能小于0）。
public void brake()方法，将汽车的当前时速设为0。
public void driving(int minutes) 方法，汽车以当前时速行驶minutes分钟，将行驶距离递加到distance（如果当前时速为0，提示“当前时速为0，请先加速”）。
该类有一个公共方法toString()，根据汽车的数据生成并返回一个字符串，形式为"Car{当前时速=****,总行驶距离=}"，可以参考输出样例。
输入样例

100 10.5

输出样例

Car{当前时速=100,总行驶距离=60.5}
Car{当前时速=20,总行驶距离=70.5}
Car{当前时速=70,总行驶距离=105.5}
当前时速为0，请先加速

import java.util.Scanner;

class Vehicle {
    private int speed;

    public Vehicle(int speed) {
        setSpeed(speed);
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        if (speed < 0)
            this.speed = 0;
        else
            this.speed = speed;
    }
}

class Car extends Vehicle {
    private double distance;

    public Car(int speed) {
        super(speed);
        this.distance = 0;
    }

    public Car(double distance) {
        super(0);
        this.distance = distance;
    }

    public Car(int speed, double distance) {
        super(speed);
        this.distance = distance;
    }

    public void increaseSpeed(int differenceInc) {
        setSpeed(getSpeed() + differenceInc);
    }

    public void decreaseSpeed(int differenceDec) {
        setSpeed(Math.max(0, getSpeed() - differenceDec));
    }

    public void brake() {
        setSpeed(0);
    }

    public void driving(int minutes) {
        if (getSpeed() == 0) {
            System.out.println("当前时速为0，请先加速");
        } else {
            double kilometers = (getSpeed() * minutes) / 60.0;
            distance += kilometers;
        }
    }

    @Override
    public String toString() {
        return "Car{当前时速=" + getSpeed() + ",总行驶距离=" + distance + "}";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int speed = input.nextInt();
        double distance = input.nextDouble();
        Car golf = new Car(speed, distance);

        golf.driving(30);
        System.out.println(golf);

        golf.decreaseSpeed(80);
        golf.driving(30);
        System.out.println(golf);

        golf.increaseSpeed(50);
        golf.driving(30);
        System.out.println(golf);

        golf.brake();
        golf.driving(30);
    }
}

14、this在构造方法的使用

class Base {
    int x, y, z, w;

    // 第一个构造器
    public Base(int a, int b) {
        x = a;
        y = b;
    }

    // 第二个构造器，通过调用第一个构造器来初始化x和y
    public Base(int a, int b, int c, int d) {
        this(a, b); // 调用第一个构造器
        z = c;
        w = d;
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用第二个构造器创建Base对象
        Base base = new Base(1, 1, 1, 1);
        // 打印出base对象的所有字段值
        System.out.println(base.x + " " + base.y + " " + base.z + " " + base.w);
    }
}

15、super使用

class Father {
    int a;

    public Father(int a) {
        this.a = a;
    }

    public void print() {
        System.out.println(a);
    }
}

class Child extends Father {
    int a; // 隐藏了父类的同名成员变量a

    public Child(int a) {
        super(a); // 将形参a的值赋给父类的成员变量a
        this.a = super.a * 10; // 将父类成员变量a的值乘以10后赋给子类的成员变量a
    }

    @Override
    public void print() {
        // 由于子类的成员变量a隐藏了父类的成员变量a，我们需要通过super来访问父类的成员变量a
        System.out.println(super.a); // 输出父类成员变量a的值
        System.out.println(this.a);  // 输出子类成员变量a的值
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child(10);
        child.print();
    }
}

16、异常抛出与捕获案例–下面程序抛出了一个“异常”并捕捉它

class Main {
    static void procedure() throws IllegalAccessException {
        System.out.println("inside procedure");
        
        // 抛出IllegalAccessException异常
        throw new IllegalAccessException("demo");
    }

    public static void main(String args[]) {
        try {
            procedure();
        } catch (IllegalAccessException e) { // 捕获IllegalAccessException异常
            System.out.println("捕获：" + e);
        }
    }
}

解释：

1. 在procedure方法中，我们使用了throw new IllegalAccessException(“demo”);来手动抛出一个IllegalAccessException异常，并附带了一条错误消息"demo"。
2. 在main方法的try-catch结构中，catch (IllegalAccessException e)子句负责捕获procedure方法可能抛出的IllegalAccessException异常。这里的e是一个IllegalAccessException类型的对象，它包含了异常的详细信息。
3. 当procedure方法抛出异常时，程序会跳转到catch子句，并打印出"捕获：“以及异常对象e的toString()方法返回的字符串（在这个例子中，它会包含我们提供的错误消息"demo”）。

17、计算整数序列和

import java.util.*;

// 定义一个线程类，用于计算整数序列的和
class SumList implements Runnable {
    private ArrayList<Integer> lt = null; // 存放整数序列的列表

    SumList(ArrayList<Integer> lt) {
        this.lt = lt;
    }

    // 实现Runnable接口的run方法，作为线程体
    @Override
    public void run() {
        int sum = 0;
        for (int i = 0; i < lt.size(); i++) {
            sum += lt.get(i); // 取出序列元素并累加
        }
        System.out.println(sum); // 输出序列的和
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 输入序列个数
        int m = sc.nextInt(); // 输入每个序列中的整数个数

        // 创建一个线程数组，用于存储线程对象
        Thread[] threads = new Thread[n];

        for (int i = 0; i < n; i++) {
            ArrayList<Integer> score = new ArrayList<>(); // 为每个序列创建一个ArrayList对象
            for (int j = 0; j < m; j++) {
                score.add(sc.nextInt()); // 向列表中添加整数
            }
            SumList sl = new SumList(score); // 创建求和列表对象
            threads[i] = new Thread(sl); // 创建线程对象
            threads[i].start(); // 启动线程
        }

        // 等待所有线程执行完毕（可选，但在此简单示例中未实现）
        // 注意：在实际应用中，应确保所有线程完成执行，例如使用join()方法或线程池等机制

        sc.close();
    }
}

注意事项：

1. SumList 类实现了 Runnable 接口，并覆盖了 run 方法。在 run 方法中，我们遍历列表 lt 并计算其元素的总和。
2. 在 Main 类的 main 方法中，我们读取了序列的数量 n 和每个序列中整数的数量 m。然后，我们为每个序列创建了一个ArrayList 对象，并使用循环读取整数填充这些列表。
3. 对于每个列表，我们创建了一个 SumList对象，并将其作为 Runnable 传递给一个新的 Thread 对象。随后，我们启动了这些线程。
4. 在此示例中，我们没有实现等待所有线程完成的机制。在实际应用中，可能需要确保所有线程都已完成执行，以避免在程序退出时仍有线程在运行。这可以通过调用join() 方法或使用 ExecutorService 和 Future 等高级线程管理工具来实现。
5. 由于线程是并发执行的，因此输出的顺序可能与序列的输入顺序不同。如果需要按特定顺序输出结果，则需要额外的同步机制。然而，对于此简单示例，我们接受输出顺序的不确定性。

18、迭代器遍历列表

import java.util.*;

/* 
假设Student类的定义如下，此部分代码在题目中被省略，但为完整性而展示：
class Student {
    private String id;
    private String name;
    private int age;

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 省略getter和setter方法
}
*/

public class Main {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();
        list.add(new Student("2016001", "rose", 18));
        list.add(new Student("2016002", "hunifu", 19));
        list.add(new Student("2016003", "britsh", 20));

        Iterator<Student> it = list.iterator(); // 初始化迭代器

        while (it.hasNext()) { // 判断是否还有下一个元素
            Student stu = it.next(); // 获取下一个元素
            System.out.println(stu);
        }
    }
}

补全的部分解释如下：

1. Iterator it =list.iterator();：通过调用ArrayList的iterator()方法来初始化一个Iterator对象，用于遍历list中的Student对象。
2. while (it.hasNext())：使用hasNext()方法来检查迭代器中是否还有下一个元素。如果有，则进入循环体。
3. Student stu =it.next();：在循环体中，通过调用next()方法来获取迭代器中的下一个Student对象，并将其赋值给变量stu。

19、在映射(Map)集合中查找指定关键字的元素

import java.util.*;

/* 
假设People类的定义如下，此部分代码在题目中被省略，但为完整性而展示：
class People {
    private String name;
    private int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 省略getter和setter方法，可以添加toString()方法以便于打印
    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
*/

public class Main {
    public static void main(String[] args) {
        Map<String, People> peoples = new HashMap<String, People>();
        // 注意：这里"hunifu"键被覆盖了，Map中最终只会保留一个"hunifu"键
        peoples.put("rose", new People("rose", 18));
        peoples.put("hunifu", new People("hunifu", 19));
        peoples.put("hunifu", new People("britsh", 20)); // 这将覆盖之前的"hunifu"键值对

        // 检查Map的元素个数是否大于0
        if (!peoples.isEmpty()) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入要查找的关键字：");
            String key = sc.next();

            // 判断关键字是否存在Map内
            if (peoples.containsKey(key)) {
                // 取出关键字指定元素
                People person = peoples.get(key);
                System.out.println(person);
            } else {
                System.out.println("映射中不存在 key = " + key + " 的元素");
            }
        } else {
            System.out.println("映射集合为空，无法进行查找");
        }

        // 关闭Scanner以释放资源（好习惯，但在这个简单的例子中可能不是必需的）
        sc.close();
    }
}

补全的部分解释如下：

1. if (!peoples.isEmpty())：使用isEmpty()方法检查Map是否为空。如果不为空（即元素个数大于0），则继续执行查找操作。
2. if (peoples.containsKey(key))：使用containsKey()方法检查Map中是否包含指定的关键字。如果包含，则执行取出元素的操作。
3. People person = peoples.get(key)：使用get()方法根据关键字取出对应的元素，并将其赋值给变量person。

20、创建列表并输出

import java.util.*;

class People {
    private String name;
    private int age;

    People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "[" + name + "," + age + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<People> list = new ArrayList<People>(); // 创建列表

        for (int i = 0; i < 3; i++) {
            System.out.print("请输入第" + (i + 1) + "个人的名字和年龄（用空格分隔）：");
            String name = sc.next();
            int age = sc.nextInt();
            list.add(new People(name, age)); // 输入3个People对象加入列表
        }

        System.out.println("列表元素个数：" + list.size()); // 输出列表元素个数
        System.out.println(list); // 输出列表内容（会自动调用每个People对象的toString方法）

        sc.close(); // 关闭Scanner对象以释放资源
    }
}

补全的部分解释如下：

1. List list = new ArrayList();：在main方法中创建一个ArrayList对象list，用于存储People对象。
2. 在for循环中，通过Scanner对象sc读取用户输入的名字和年龄，并创建People对象添加到list中。注意，sc.next()用于读取字符串（名字），sc.nextInt()用于读取整数（年龄）。由于这两个方法连续调用，用户需要在输入名字和年龄时用空格分隔。
3. System.out.println(“列表元素个数：” + list.size());：使用size()方法获取list中的元素个数，并打印出来。
4. System.out.println(list);：直接打印list对象，由于list中的元素是People对象，而People类重写了toString()方法，因此这里会调用每个People对象的toString()方法来生成字符串表示，并打印出来。

21、在链表集合中增加/删除元素

本题目已定义一个 People 类。属性：名字(name）、年龄(age)；方法：getName() 获取名字、toString() 输出对象。
现使用链表存储 People 对象。首先，通过输入创建 People 对象并插入到链表；然后，删除指定名字的链表元素。

import java.util.*;

// 假设 People 类已经定义如下（在实际应用中，您应该将这个类放在单独的文件中）
class People {
    private String name;
    private int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "People{name='" + name + "', age=" + age + "}";
    }
}

public class Main {
    public static void main(String args[]) {
        LinkedList<People> peoples = new LinkedList<People>(); // 创建链表
        Scanner sc = new Scanner(System.in);

        // 链表初始化，添加一个已知对象
        peoples.add(new People("rose", 18));

        // 从控制台读取输入，创建新对象并添加到链表头部
        System.out.print("请输入第一个人的名字和年龄（空格分隔）：");
        People p = new People(sc.next(), sc.nextInt());
        peoples.addFirst(p); // 新对象加到链表头

        // 再次从控制台读取输入，创建新对象并添加到链表尾部
        System.out.print("请输入第二个人的名字和年龄（空格分隔）：");
        p = new People(sc.next(), sc.nextInt());
        peoples.addLast(p); // 新对象加到链表尾

        // 输入要删除的名字
        System.out.print("请输入要删除的人的名字：");
        String nameToDelete = sc.next();

        // 遍历链表，删除指定名字的元素
        Iterator<People> iterator = peoples.iterator();
        while (iterator.hasNext()) {
            p = iterator.next();
            if (p.getName().equals(nameToDelete)) {
                iterator.remove(); // 若名字相等，删除该元素
                break; // 假设名字唯一，找到后退出循环
            }
        }

        // 输出链表
        System.out.println(peoples);

        sc.close();
    }
}

22、创建线程执行整数序列的求和计算

import java.util.*;

// 声明线程类，继承自Thread
class SumList extends Thread {
    private ArrayList<Integer> lt = null; // 整数序列
    private int sum; // 序列和

    SumList(ArrayList<Integer> lt) {
        this.lt = lt;
    }

    // 返回求和结果值，注意：这个方法在线程运行完毕之前调用可能会得到未初始化的sum值
    // 因此，应该在线程结束后调用，或者通过其他同步机制来获取正确的sum值
    public int getSum() {
        return sum;
    }

    // 线程体，必须重写run()方法
    @Override
    public void run() {
        sum = 0;
        for (int i = 0; i < lt.size(); i++) {
            sum += lt.get(i);
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(); // 输入序列中的整数个数
        ArrayList<Integer> lt = new ArrayList<Integer>();
        for (int j = 0; j < m; j++) {
            lt.add(sc.nextInt()); // 输入序列
        }
        SumList sumThread = new SumList(lt); // 创建线程对象

        sumThread.start(); // 启动线程

        sumThread.join(); // 等待线程结束

        System.out.println(sumThread.getSum()); // 输出求和结果

        sc.close();
    }
}

23、创建线程执行阶乘计算

import java.util.*;

class Factorial implements Runnable { // 声明线程类并实现Runnable接口
    private int n;
    private long factorial;

    Factorial(int n) {
        this.n = n;
    }

    // 返回阶乘
    public long getFactorial() {
        return factorial;
    }

    // 线程体
    @Override
    public void run() { // 线程类必须实现接口定义的方法
        factorial = 1;
        for (int i = 2; i <= n; i++)
            factorial = factorial * i;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        Factorial fac = new Factorial(number);

        Thread th = new Thread(fac); // 创建线程
        th.start(); // 启动线程
        th.join(); // 等待线程结束
        System.out.println(fac.getFactorial()); // 输出阶乘
    }
}

24、Java继承中构造方法的执行

public class Main
{
    public static void main(String[] args)
    {
        // 空参实例化Son的对象s
        Son s = new Son(); // 这里会触发Son的空参构造方法，进而触发Father的有参构造方法（通过super调用）
    }
}

class Father
{
    private String name;
    private int age;

    // Father类的空参构造方法，输出“Father的空参构造方法被执行了”
    public Father() {
        System.out.println("Father的空参构造方法被执行了");
    }

    public Father(String name, int age)
    {
        this.name = name;
        this.age = age;
        System.out.println("Father的有参构造方法被执行了");
    }
}

class Son extends Father
{
    public Son()
    {
        // 调用Father类的有参构造方法，两个参数：张三，18
        // 注意：这里直接调用父类的有参构造方法是不符合常规做法的，但为了满足题目要求，我们这样做
        // 正常情况下，应该通过某种方式（如构造函数参数、配置文件等）来获取这些值
        super("张三", 18); // 使用super关键字调用父类的构造方法
        System.out.println("Son的空参构造方法被执行了"); // 这条语句会在调用完父类构造方法后执行
    }

    public Son(String name, int age)
    {
        super(name, age); // 调用父类的有参构造方法
        System.out.println("Son的有参构造方法被执行了");
    }
}

25、Java类继承实例化构造方法的执行

public class Main
{
    public static void main(String[] args)
    {
        Son s = new Son(); // 空参实例化Son类的对象s
    }
}

class Father
{
    public Father() {
        System.out.println("Father的空参构造方法被执行了");
    }

    public Father(int i)
    {
        System.out.println(i);
    }
}

class Son extends Father
{
    public Son() {
        super(); // 调用父类的空参构造方法
        System.out.println("Son的空参构造方法被执行了");
    }
}

26、Java继承中子父类同名成员变量、局部变量的访问

public class Main {
    public static void main(String[] args) {
        // 空参实例化Zi类对象z
        Zi z = new Zi();
        
        // 调用对象z的show()方法
        z.show();
    }
}

class Fu {
    public int num = 10; // 父类的成员变量num
    public Fu() {
        System.out.println("Fu的构造方法被执行了");
    }
}

class Zi extends Fu {
    public int num = 20; // 子类的成员变量num，隐藏了父类的同名变量
    public Zi() {
        super(); // 调用父类的构造方法
        System.out.println("Zi的构造方法被执行了");
    }
    
    public void show() {
        int num = 30; // 局部变量num，作用域仅限于show()方法内部
        
        // 输出子类的成员变量num的值
        System.out.println(this.num); // 输出20，因为this.num引用的是子类的成员变量
        
        // 输出父类的成员变量num的值
        System.out.println(super.num); // 输出10，因为super.num引用的是父类的成员变量
        
        // 注意：不能直接输出局部变量的值而不使用变量名
        // 但由于我们需要在注释中说明，这里用输出语句占位，实际运行时应该去掉或替换为有效的输出
        // 由于局部变量num的作用域问题，我们不能在show()方法外部访问它
        // 但为了符合题目要求（在注释中说明），我们保留这个输出语句并解释它应该被替换或移除
        // System.out.println(num); // 这行代码在实际代码中是有效的，会输出30，但这里仅作为占位符
        
        // 正确输出局部变量num的值（已在上一行完成，但为了说明，我们再次指出）
        System.out.println(num); // 输出30，这是show()方法内部的局部变量
        
        // 注意：为了清晰起见，通常不会在同一个作用域内使用多个同名的变量（包括局部变量和成员变量）
        // 这会导致代码难以理解和维护。在实际编程中，应避免这种做法。
    }
}

27、Java多态重写方法的调用执行

public class Main {
    public static void main(String[] args) {
        // 创建一个C类的对象，并使用B类的引用来指向它
        B b = new C();
        
        // 调用b的show()方法，该方法在C类中被重写以调用其父类B的show()方法（通过super），
        // 而B类的show()方法又调用了show2()，此时会调用B类自己的show2()方法，因为B类重写了A类的show2()。
        b.show();
    }
}

class A {
    public void show() {
        // 调用当前对象的show2()方法，根据多态性，实际调用的是运行时对象的show2()方法
        show2();
    }
    
    public void show2() {
        System.out.println("我");
    }
}

class B extends A {
    @Override
    public void show2() {
        System.out.println("恨");
    }
}

class C extends B {
    @Override
    public void show() {
        // 调用父类B的show()方法
        super.show();
        
        // 如果需要，也可以在这里调用C类自己的show2()方法，但当前代码没有这样做
        // this.show2(); // 会输出 "Java"
    }
    
    @Override
    public void show2() {
        System.out.println("Java");
    }
}

28、Java多态、普通类继承抽象类实现接口

public class Main {
    public static void main(String[] args) {
        JumpCat jc = new JumpCat("Tom猫");
        jc.eat();
        jc.jump(jc.getName());
        // 可以选择调用sleep()方法来验证它的实现
        jc.sleep();
    }
}

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 声明为抽象方法，要求所有子类实现
    public abstract void eat();
    public abstract void sleep();
}

interface Jumping {
    void jump(String name);
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("猫都爱吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("爬着睡");
    }
}

class JumpCat extends Cat implements Jumping {
    public JumpCat(String name) {
        super(name);
    }

    @Override
    public void jump(String name) {
        System.out.println(name + "跳高");
    }

    // 如果JumpCat有特殊的sleep行为，可以在这里重写它，否则继承Cat的实现即可
    // @Override
    // public void sleep() {
    //     // 自定义的sleep行为
    // }
}

29、矩形类

构造一个Rectangle类表示矩形 ， 该类实现了Comparable接口。
该类有两个私有的double型成员变量width和height，表示矩形的宽度和高度；
该类有一个带一个无参的构造方法，把宽带和高度都初始化为0；
该类有一个带两个double型参数的构造方法，用参数的值初始化矩形的宽度和高度。
为width和height添加getter()和setter()方法。注意，宽度和高度必须大于等于0，如果setWidth(double width)方法的参数小于0时，抛出一个IllegalArgumentException异常对象，异常对象的成员变量message为"矩形的宽度必须大于等于0"；setHeight(double height)方法的参数小于0时，抛出一个IllegalArgumentException异常对象，异常对象的成员变量message为"矩形的高度必须大于等于0"。
getArea()方法，返回矩形的面积；
getgetPerimeter()方法，返回矩形的周长；
该类有一个公共的方法int compareTo(Rectangle rectangle)，比较当前对象和参数。如果当前对象的面积大于参数的面积，返回1；当前对象的面积小于参数的面积，返回-1；否则返回0。
该类有一个公共方法toString()，根据矩形的宽度和高度生成并返回一个字符串（具体要求看输出样例）。
构造一个Main ，执行一个for循环，共循环6次。每次循环从键盘读入数据创建两个矩形对象，比较并输出其中较大的对象的面积；如果捕捉到异常，则输出异常信息。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        for (int i = 0; i < 6; i++) {
            try {
                System.out.print("请输入第一个矩形的宽度和高度：");
                double w1 = input.nextDouble();
                double h1 = input.nextDouble();
                Rectangle rectangle1 = new Rectangle(w1, h1);

                System.out.print("请输入第二个矩形的宽度和高度：");
                double w2 = input.nextDouble();
                double h2 = input.nextDouble();
                Rectangle rectangle2 = new Rectangle(w2, h2);

                Rectangle maxRectangle = (rectangle1.compareTo(rectangle2) >= 0) ? rectangle1 : rectangle2;
                System.out.println("矩形 " + rectangle1 + " 和 " + rectangle2 + " 中面积较大的是 " + maxRectangle + "，面积为 " + maxRectangle.getArea());
            } catch (IllegalArgumentException e1) {
                System.out.println(e1.getMessage());
                input.nextLine(); // 消耗掉输入缓冲区中的换行符，避免影响下一次输入
            } catch (Exception e2) {
                System.out.println("发生未知异常：" + e2.getMessage());
                input.nextLine(); // 消耗掉输入缓冲区中的换行符，避免影响下一次输入
            }
        }
        input.close();
    }
}

class Rectangle implements Comparable<Rectangle> {
    private double width;
    private double height;

    public Rectangle() {
        width = 0;
        height = 0;
    }

    public Rectangle(double width, double height) {
        this.setWidth(width);
        this.setHeight(height);
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        if (width >= 0) {
            this.width = width;
        } else {
            throw new IllegalArgumentException("矩形的宽度必须大于等于0");
        }
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        if (height >= 0) {
            this.height = height;
        } else {
            throw new IllegalArgumentException("矩形的高度必须大于等于0");
        }
    }

    public double getArea() {
        return width * height;
    }

    public double getPerimeter() {
        return 2 * (width + height);
    }

    @Override
    public int compareTo(Rectangle rectangle) {
        double thisArea = this.getArea();
        double otherArea = rectangle.getArea();
        if (thisArea > otherArea) {
            return 1;
        } else if (thisArea < otherArea) {
            return -1;
        } else {
            return 0;
        }
    }

    @Override
    public String toString() {
        return "Rectangle[width=" + width + ", height=" + height + "]";
    }
}

30、类和对象的创建和使用

定义一个Person类，该类包括age，name两个数据成员和eat(),work()两个成员方法，并实现对两个数据成员的Getter方法。然后通过测试程序，实现相应对象的操作。程序输出结果如下：

class Person {
    public int age;             // 声明公共字段age
    private String name;        // 声明私有字段name

    public int getAge() { // 实现age成员的Getter方法
        return age;
    }

    public String getName() { // 实现name成员的Getter方法
        return name;
    }

    public void eat() { // 定义无参数的eat方法
        System.out.println("会生活");
    }

    public void work(String s) { // 定义带参数的work方法
        System.out.println("努力创造" + s);
    }

    public Person(int age, String name) { // 定义一个带参数构造函数
        this.age = age;
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person(18, "张三"); // 调用类的有参构造函数
        System.out.println("姓名:" + p.getName() + "\n年龄:" + p.getAge());

        p.eat(); // 调用对象的eat方法
        p.work("美好生活"); // 调用对象的work方法
    }
}

31、设计一个ComparableCircle类继承自Circle类并实现Comparable接口

设计一个Circle类，该类有属性radius，表示圆的半径，其默认值为1；getArea()返回该圆的面积。
创建一个名为ComparableCircle的类，它继承自Circle类，并实现Comparable接口，在类中实现compareTo方法，使其根据面积比较两个圆。
编写测试程序求出两个ComparableCircle实例对象的较大者。程序输出如下信息：
Cirlce: radius = 7.0
Area: 153.93804002589985
Cirlce: radius = 5.0
Area: 78.53981633974483
c1较大

class Circle {
    private double radius;

    public Circle() {
        radius = 1; // 默认值设置为1
    }

    public Circle(double radius) {
        this.radius = radius; // 初始化半径
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        // 圆的面积公式：πr²
        return Math.PI * radius * radius;
    }

    @Override
    public String toString() {
        // 返回一个描述圆的字符串
        return "Circle: radius = " + radius;
    }
}

class ComparableCircle extends Circle implements Comparable<ComparableCircle> {

    public ComparableCircle() {
        super(); // 调用父类的无参构造函数
    }

    public ComparableCircle(double radius) {
        super(radius); // 调用父类的有参构造函数
    }

    @Override
    public int compareTo(ComparableCircle o) {
        // 根据面积比较两个圆
        if (getArea() > o.getArea())
            return 1;
        else if (getArea() < o.getArea())
            return -1;
        else
            return 0;
    }

    @Override
    public String toString() {
        // 返回一个描述圆的字符串，包括半径和面积
        return "Circle: radius = " + getRadius() + "\nArea: " + getArea();
    }
}

public class Main {
    public static void main(String[] args) {
        ComparableCircle c1 = new ComparableCircle(7);
        ComparableCircle c2 = new ComparableCircle(5);
        System.out.println(c1);
        System.out.println(c2);
        // 比较两个圆，并输出较大的圆
        System.out.println((c1.compareTo(c2) > 0) ? "c1较大" : "c2较大");
    }
}

32、创建一个Box类，求其体积

设计并实现Box类，它包含盒子的高度、宽带和深度的实例数据：还包含布尔变量full这个实例数据，变量full表示盒子是否满了。所有数据都定义为私有。定义Box构造函数接收并初始化盒子的高度、宽带和深度。每次新创建的Box都为空，构造函数将full初始化为假。该类所有实例都有getter和setter方法；该类还包含了一个计算盒子体积的方法。
该类包含一个toString方法，用来返回一行关于盒子的描述。
例如，输入的长、宽、高分别为4，如果盒子为空，则输出：
Box is empty, The Volumn is 64
若将盒子的宽度修改为5，盒子设置为满，则输出：
Box is full, The Volumn is 80
创建一个测试类BoxTest，其main方法输入盒子的长、宽、高，实例化一个Box对象，并输出盒子的描述。
根据以下的测试类，在空格出填入Box类的设计程序。

import java.util.Scanner;

class Box {
    private boolean full;
    private int width;
    private int height;
    private int length; // 注意这里修正了拼写错误，应为length

    // Box类的构造函数
    public Box(int width, int height, int length) {
        this.full = false; // 初始化full为false，表示新创建的Box为空
        this.width = width;
        this.height = height;
        this.length = length;
    }

    // full的getter方法
    public boolean isFull() {
        return full;
    }

    // full的setter方法
    public void setFull(boolean full) {
        this.full = full;
    }

    // width的getter方法
    public int getWidth() {
        return width;
    }

    // width的setter方法
    public void setWidth(int width) {
        this.width = width;
    }

    // height的getter方法
    public int getHeight() {
        return height;
    }

    // height的setter方法，注意参数名应与形参一致，这里我使用了height而不是h
    public void setHeight(int height) {
        this.height = height;
    }

    // length的getter方法
    public int getLength() { // 注意这里修正了拼写错误，应为getLength
        return length;
    }

    // length的setter方法
    public void setLength(int length) { // 注意这里修正了拼写错误，应为setLength
        this.length = length;
    }

    // 计算盒子体积的方法
    public int getVolume() { // 注意这里修正了拼写错误，应为getVolume
        return width * height * length;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "Box is " + (full ? "full" : "empty") + ", The Volume is " + getVolume(); // 注意这里也修正了拼写错误，应为Volume
    }
}

public class Main {
    // main方法，程序的入口点
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int w = input.nextInt(); // 读取宽度
        int h = input.nextInt(); // 读取高度
        int l = input.nextInt(); // 读取长度
        Box box1 = new Box(w, h, l); // 使用输入的宽、高、长来实例化Box对象

        System.out.println(box1.toString()); // 输出盒子的描述
        box1.setWidth(5); // 修改盒子的宽度
        box1.setFull(true); // 将盒子设置为满
        System.out.println(box1.toString()); // 再次输出盒子的描述

        input.close(); // 关闭Scanner以释放资源
    }
}

33、学生按年龄排序、查找

有一学生类（Student），含有姓名（name）、年龄（age）属性，该类实现Comparable接口，要求重写compareTo方法，实现按照年龄的大小来确定两个学生的大小关系。
在链表中添加3个学生对象，通过Collections类的sort方法对链表中的学生按照年龄升序排序。输入第4个学生对象，并查找他（她）的年龄是否与链表中某个学生的年龄相同。

import java.util.*;

class Student implements Comparable<Student> {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student stu) {
        // 按照年龄升序排序，如果年龄相同则返回0
        return Integer.compare(this.age, stu.age);
    }

    @Override
    public String toString() {
        return "姓名：" + name + "，年龄：" + age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> list = new LinkedList<>();

        Scanner sc = new Scanner(System.in);

        System.out.println("输入三个学生的信息：");
        for (int i = 0; i < 3; i++) {
            list.add(new Student(sc.next(), sc.nextInt()));
        }

        Iterator<Student> it = list.iterator();
        System.out.println("排序前，链表中的数据：");
        while (it.hasNext()) {
            System.out.println(it.next().toString());
        }

        // 排序
        Collections.sort(list);

        System.out.println("排序后，链表中的数据：");
        it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next().toString());
        }

        System.out.println("输入要查找的学生信息：");
        Student stu4 = new Student(sc.next(), sc.nextInt());

        // 注意：这里使用binarySearch前，列表必须是已经排序的
        int index = Collections.binarySearch(list, stu4, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                return Integer.compare(s1.age, s2.age);
            }
        });

        // binarySearch返回的索引是插入点，如果返回的是负数，则使用其绝对值减一得到相同元素的索引（如果存在的话）
        // 但在这里，我们只需要检查是否找到了相同年龄的学生
        if (index >= 0) {
            System.out.println(stu4.name + "与链表中的" + list.get(index).name + "年龄相同");
        } else {
            // 注意：binarySearch返回负值表示未找到，但不能直接使用负值作为索引
            // 如果需要找到相同年龄的学生（如果存在多个），需要额外处理
            // 但这里只检查是否存在至少一个相同年龄的学生
            boolean found = false;
            for (Student stu : list) {
                if (stu.age == stu4.age) {
                    System.out.println(stu4.name + "与链表中的某个学生年龄相同（但不保证是" + stu.name + "，因为可能有多个相同年龄的学生）");
                    found = true;
                    break; // 如果只需要知道是否存在，找到后即可退出循环
                }
            }
            if (!found) {
                System.out.println("链表中的对象，没有一个与" + stu4.name + "年龄相同的");
            }
            // 注意：上面的处理稍显冗余，因为在这个特定例子中，我们已经知道列表是按年龄排序的，
            // 所以如果binarySearch返回负值，我们只需要检查该负值的绝对值减一对应的学生年龄即可，
            // 但为了展示更通用的检查方法，我保留了上面的循环。
            // 在实际应用中，可以根据需求选择更优化的方法。
            // 另外，上面的输出信息也做了调整，以更准确地反映实际情况。
        }

        sc.close();
    }
}

34、自定义异常类：成绩异常（ScoreException）

自定义一个异常类ScoreException，继承自Exception类。有一个私有的成员变量message（异常提示信息，String类型）；一个公有的无参数的构造方法，在方法中将message的值确定为“您输入的成绩异常，请核实！”；一个公有的方法show()，该方法的功能是输出message的值。
定义一个学生类Student，有一个私有成员变量score（成绩，double类型）；一个带参数的公有方法setScore()用于设置学生的成绩，该方法声明可能抛出异常ScoreException，当设置的成绩为负数或超过100时，会抛出一个异常对象；一个公有方法getScore()用于获取学生的成绩。
在测试类Main中，创建一个Student类的对象zhangsan，尝试调用setScore()方法来设置他的成绩（成绩从键盘输入，double类型），然后调用getScore()方法获取到该成绩后再将其输出。因用户的输入存在不确定性，以上操作有可能捕捉到异常ScoreException，一旦捕捉到该异常，则调用show()方法输出异常提示。不管是否有异常，最终输出“程序结束”。使用try…catch…finally语句实现上述功能。

在这里插入代码片
```import java.util.Scanner;

// 自定义异常类 ScoreException
class ScoreException extends Exception {
    private String message;

    public ScoreException() {
        message = "您输入的成绩异常，请核实！";
    }

    public void show() {
        System.out.println(message);
    }
}

// 学生类 Student
class Student {
    private double score;

    // 设置成绩，若成绩不合法则抛出 ScoreException
    public void setScore(double score) throws ScoreException {
        if (score < 0 || score > 100) {
            throw new ScoreException(); // 抛出异常对象
        } else {
            this.score = score; // 合法成绩则设置
        }
    }

    // 获取成绩
    public double getScore() {
        return this.score;
    }
}

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

        try {
            System.out.print("请输入张三的成绩: ");
            double inputScore = sc.nextDouble();
            zhangsan.setScore(inputScore); // 尝试设置成绩
            System.out.println("成绩为: " + zhangsan.getScore()); // 输出成绩
        } catch (ScoreException e) {
            e.show(); // 捕捉到异常，输出异常提示
        } finally {
            System.out.println("程序结束"); // 无论是否异常，最终输出程序结束
        }

        sc.close(); // 关闭扫描器
    }
}

35、Java中，去除集合ArrayList中重复自定义对象元素

本题目要求：
在执行System.out.println(newList);语句后，打印“[Student [name=张三, age=23], Student [name=李四, age=24], Student [name=王五, age=25]]”。
样例程序：

import java.util.ArrayList;
import java.util.Iterator;

public class Main {

    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 24));
        list.add(new Student("李四", 24));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("王五", 25));
        list.add(new Student("王五", 25));
        list.add(new Student("王五", 25));
        
        ArrayList<Student> newList = getSingle(list);
        
        System.out.println(newList);
        // 输出：[Student [name=张三, age=23], Student [name=李四, age=24], Student [name=王五, age=25]]
    }

    private static ArrayList<Student> getSingle(ArrayList<Student> list) {
        ArrayList<Student> newList = new ArrayList<>();
        Iterator<Student> it = list.iterator();

        while (it.hasNext()) {
            Student student = it.next();
            if (!newList.contains(student)) { // 使用contains方法依赖于equals方法的重写
                newList.add(student);
            }
        }
        return newList;
    }

}

class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return age == student.age && name.equals(student.name);
    }

    // 注意：虽然在这个特定场景中我们可能不需要hashCode方法，但重写它是一个好的实践
    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        return result;
    }
}

36、学位论文

编写一个接口References和两个类Paper和Dissertation。
(1)编写一个接口References表示参考文献，包含以下成员
①方法：
String reference()，返回参考文献的引文格式。
(2)编写一个Paper类表示论文，包含以下成员
①属性：
title：私有，String型，表示论文标题。
author：私有，String型，表示论文作者。
②方法：
Paper(String title, String author)，构造方法，用参数分别初始化标题和作者；
为title和author添加getter和setter方法。
(3)编写一个Paper类的子类Dissertation，表示学位论文。Dissertation类实现了References接口。Dissertation类包含以下成员
①属性：
city：私有，String型，表示城市。
school：私有，String型，表示学校。
year：私有，int型，表示发表年份。
②方法：
Dissertation(String title, String author, String city, String school, int year)，构造方法，用参数分别初始化title、author、city、school和year等成员变量；
为city、school和year添加getter和setter方法。
重写reference()方法，返回字符串，格式为“作者．题名[D]．保存地：保存单位，年份．”。
(4)构造一个Main类。
在main方法中，用Scanner对象输入数据，并创建一个Dissertation对象，并输出其参考文献的引文格式。

import java.util.Scanner;

// 定义接口 References
interface References {
    String reference();
}

// 定义类 Paper
class Paper {
    private String title;
    private String author;

    public Paper(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

// 定义类 Dissertation，继承 Paper 并实现 References 接口
class Dissertation extends Paper implements References {
    private String city;
    private String school;
    private int year;

    public Dissertation(String title, String author, String city, String school, int year) {
        super(title, author); // 调用父类构造方法
        this.city = city;
        this.school = school;
        this.year = year;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public String reference() {
        return getAuthor() + "．" + getTitle() + "[D]．" + getCity() + "：" + getSchool() + "，" + year + "．";
    }
}

// 定义主类 Main
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 指定输入源为 System.in

        // 提示用户输入数据
        System.out.print("请输入论文标题: ");
        String title = scanner.next();
        System.out.print("请输入论文作者: ");
        String author = scanner.next();
        System.out.print("请输入城市: ");
        String city = scanner.next();
        System.out.print("请输入学校: ");
        String school = scanner.next();
        System.out.print("请输入发表年份: ");
        int year = scanner.nextInt();

        // 创建 Dissertation 对象
        Dissertation dissertation = new Dissertation(title, author, city, school, year);

        // 输出参考文献的引文格式
        System.out.println(dissertation.reference());

        // 关闭 Scanner 对象
        scanner.close();
    }
}

37、雇员和经理

编写一个两个类Employee和Manager。
(1)编写一个类Employee表示雇员，它实现了Comparable接口，包含以下成员
①属性：
name：私有，String型，表示姓名。
salary：私有，int型，表示工资。
②方法：
Empolyee(String name, int salary)，构造方法，用参数分别初始化姓名和工资；
为name和salary添加getter和setter方法。
int compareTo(Empolyee o)方法，返回当前对象的工资和参数o的工资之差。
一个toString()方法，返回的字符串格式为“雇员姓名(工资金额)”，如张三工资5000，返回“雇员张三(工资5000)”。
(2)编写一个Manager类表示经理，Employee的子类，包含以下成员
①属性：
bonus：私有，int型，表示奖金。
②方法：
Manager(String name, int salary, int bonus)，构造方法，用参数分别初始化姓名、工资和奖金。
为bonus添加getter和setter方法。
重写getSalary()方法，返回总工资金额，也就是工资和奖金的和。
重写toString()方法，返回的字符串格式为“经理姓名(工资总金额,其中奖金金额)”，如李四工资5000，奖金2000，返回“经理李四(工资7000,其中奖金2000)”。
(3)构造一个Main类。
在main方法中，写一个循环执行3次，每次用Scanner对象输入数据，并创建一个Employee对象a和一个Manager对象b，比较并输出谁的工资高。

import java.util.Scanner;

class Employee implements Comparable<Employee> {
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public int compareTo(Employee o) {
        return Integer.compare(this.salary, o.salary);
    }

    @Override
    public String toString() {
        return "雇员" + this.name + "(工资" + this.salary + ")";
    }
}

class Manager extends Employee {
    private int bonus;

    public Manager(String name, int salary, int bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    @Override
    public int getSalary() {
        return super.getSalary() + this.bonus;
    }

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    @Override
    public String toString() {
        return "经理" + this.getName() + "(工资" + this.getSalary() + ",其中奖金" + this.bonus + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            System.out.println("请输入雇员姓名和工资（格式：姓名 工资）：");
            String empName = scanner.next();
            int empSalary = scanner.nextInt();
            Employee a = new Employee(empName, empSalary);

            System.out.println("请输入经理姓名、工资和奖金（格式：姓名 工资 奖金）：");
            String mgrName = scanner.next();
            int mgrSalary = scanner.nextInt();
            int mgrBonus = scanner.nextInt();
            Employee b = new Manager(mgrName, mgrSalary, mgrBonus);

            if (a.compareTo(b) > 0) {
                System.out.println(a + "的工资收入高于" + b);
            } else if (a.compareTo(b) < 0) {
                System.out.println(a + "的工资收入低于" + b);
            } else {
                System.out.println(a + "和" + b + "的工资收入相等");
            }
        }

        scanner.close();
    }
}

38、写日记

小朋友有写日记的习惯，但有一个奇怪的规定，日记中不能出现字符#。

(1)编写一个类DiaryBook表示日记本，包含以下成员
①属性：
author：私有，String型，表示作者。
content：私有，String型，表示日记本中的内容。
②方法：
DiaryBook(String author)，构造方法，用参数初始化姓名，将内容初始化空字符串；
DiaryBook(String author, String content)，构造方法，用参数分别初始化作者和内容；
为author和content添加getter和setter方法。
write(char c)方法，往日记内容中写入一个字符。如果c是#号，抛出IllegalArgumentException异常；否则，往content末尾添加字符c；
write(String newContent)方法，往日记内容中写入一个字符串。调用write(char c)方法，将字符串中的字符依次写入日记中；一旦捕捉到异常，终止写操作；无论是否有异常，都要往日记内容末尾添加一个换行符；
boolean equals(Object obj)方法，比较当前对象和参数obj是否相等，如果obj是日记本对象，返回当前对象和obj的内容是否完全相同；如果obj不是日记本对象，返回false。
一个toString()方法，返回日记本的作者和内容等信息。
(2)构造一个Main类。
在main方法中，为小明和小白各创建一个日记本对象。小明的日记本内容初始为空字符串，随后往其中写入5行文字。小白的日记本内容初始就有一行文字，随后往其中写入4行文字。
最后比较并输出两者的日记内容是否相同。

import java.util.Scanner;

class DiaryBook {
    private String author;
    private String content;

    public DiaryBook(String author) {
        this.author = author;
        this.content = "";
    }

    public DiaryBook(String author, String content) {
        this.author = author;
        this.content = content;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public void write(char c) {
        if (c != '#') {
            content += c;
        } else {
            throw new IllegalArgumentException("日记中不能出现#号!");
        }
    }

    public void write(String newContent) {
        try {
            for (int i = 0; i < newContent.length(); i++) {
                write(newContent.charAt(i));
            }
        } catch (IllegalArgumentException e) {
            System.out.println("出现异常：" + e.getMessage());
        } finally {
            content += "\n";
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof DiaryBook) {
            return content.equals(((DiaryBook) obj).getContent());
        } else {
            return false;
        }
    }

    @Override
    public String toString() {
        return author + "的日记:\n" + content;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        DiaryBook a = new DiaryBook("小明");
        for (int i = 0; i < 5; i++) {
            try {
                a.write(scanner.nextLine());
            } catch (IllegalArgumentException e) {
                System.out.println(e.getMessage());
            }
        }
        System.out.println(a);

        DiaryBook b = new DiaryBook("小白", scanner.nextLine() + "\n");
        for (int i = 0; i < 4; i++) {
            try {
                b.write(scanner.nextLine());
            } catch (IllegalArgumentException e) {
                System.out.println(e.getMessage());
            }
        }
        System.out.println(b);

        if (a.equals(b)) {
            System.out.println("两本日记完全相同");
        } else {
            System.out.println("两本日记不同");
        }

        scanner.close();
    }
}

39、super关键字——访问父类的成员变量和方法

class Animal {
    String name = "牧羊犬";     // 名字
    void shout() {
        System.out.println("动物发出叫声");
    }
}

class Dog extends Animal {   // Dog是Animal的子类
    @Override
    public void shout() {
        // 调用父类Animal的shout()方法
        super.shout();
        System.out.println("汪汪汪……");
    }

    public void printName() {   // 输出名字
        System.out.println("名字：" + name);  // 访问父类Animal的name属性
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();  // 创建Dog类的实例
        dog.shout();  // 调用Dog类的shout()方法
        dog.printName();  // 调用Dog类的printName()方法
    }
}

40、银行账户

编写一个Java程序，包含类Acount、Main。
(1)编写一个类Account表示普通账户对象，该类实现了Comparable接口，包含以下成员
①属性：
id：私有，int型，表示账户编号；
balance：私有，int型，表示账户余额；
②方法：
Account(), 构造方法，id和balance都初始化为0；
Account(int id，int balance)，构造方法，用参数设置账户编号和余额，如果balance为负数，则抛出一个IllegalArgumentException异常，其详细信息为"账户余额不能为负数"；
void setBalance(int balance): 用参数balance修改账户金额的值，如果balance为负数，则抛出一个IllegalArgumentException异常，其详细信息为"账户余额不能为负数"；
int getBalance(): 返回账户金额
boolean withdraw(int money)：从本账户提取数额为money的现金，如果余额不足，则抛出一个IllegalArgumentException异常，其详细信息为"账户余额少于取款金额，取款失败"；
void deposit(int money)：向本账户存入数额为money的现金；
void transfer(Account account, int money)：从本账户向account账户转账，数额为money，如果余额不足，则抛出一个IllegalArgumentException异常，其详细信息为"账户余额少于转账金额，转账失败"；
void transfer(Account account)：将本账户的余额全部转账到account账户；
该类有一个公共的方法int compareTo(Account acount)，比较当前账户和参数中的账户account，返回两者余额的差值（余额大的的被认为大于另一方）。
一个公共方法public boolean equals(Object o)，比较当前对象跟参数是否相等。如果参数也是Account 类的对象且与当前对象的余额相等，则认为两个账户相等，否则不相等。
public String toString():将把当前账户对象的信息转换成字符串形式，例如id为123，余额为1000,返回字符串"Account[id:123,balance:100]“。
(3)编写公共类Main,实现如下功能
输入一个整数n，表示有n组测试数据；
循环n次。
每次循环从键盘读入数据并创建2个银行账户a和b。
然后读入一个字符串op和整数money，op表示操作指令，money表示操作金额。op为"withdraw”，表示向账户a存入金额money；op为"deposit"，表示从账户a取款金额money；op为"transfer"，表示从账户a向账户b转账金额money；op为"transferAll"，表示从账户a中所有的余额都转账到账户b中。
根据op和money的值，执行相应的操作。
如果操作成功，输出 op+“操作成功”；
如果产生异常，输出异常的详细信息；
无论是否有异常，且银行账户a和b都创建成功，本次循环最后都要分别输出用compareTo()方法和equals()方法比较两者的情况。

import java.util.Scanner;

class Account implements Comparable<Account> {
    private int id;
    private int balance;

    public Account() {
        id = 0;
        balance = 0;
    }

    public Account(int id, int balance) {
        this.id = id;
        if (balance < 0) {
            throw new IllegalArgumentException("账户余额不能为负数");
        }
        this.balance = balance;
    }

    public void setBalance(int balance) {
        if (balance < 0) {
            throw new IllegalArgumentException("账户余额不能为负数");
        }
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void withdraw(int money) {
        if (balance < money) {
            throw new IllegalArgumentException("账户余额少于取款金额，取款失败");
        }
        balance -= money;
    }

    public void deposit(int money) {
        balance += money;
    }

    public void transfer(Account account, int money) {
        if (balance < money) {
            throw new IllegalArgumentException("账户余额少于转账金额，转账失败");
        }
        balance -= money;
        account.deposit(money);
    }

    public void transfer(Account account) {
        int transferAmount = balance;
        balance = 0;
        account.deposit(transferAmount);
    }

    @Override
    public int compareTo(Account account) {
        return Integer.compare(this.balance, account.balance);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Account account = (Account) obj;
        return balance == account.balance;
    }

    @Override
    public String toString() {
        return "Account[id:" + id + ",balance:" + balance + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n;

        n = input.nextInt();
        for (int i = 0; i < n; i++) {
            Account a = null, b = null;
            try {
                System.out.println("第" + i + "次操作");
                a = new Account(input.nextInt(), input.nextInt());
                b = new Account(input.nextInt(), input.nextInt());
                String op;
                int money;
                op = input.next();
                money = input.nextInt();
                if (op.equals("withdraw")) {
                    a.withdraw(money);
                } else if (op.equals("deposit")) {
                    a.deposit(money);
                } else if (op.equals("transfer")) {
                    a.transfer(b, money);
                } else if (op.equals("transferAll")) {
                    a.transfer(b);
                }
                System.out.println(op + "操作成功");
            } catch (IllegalArgumentException e) {
                System.out.println(e.getMessage());
            } finally {
                if (a != null && b != null) {
                    System.out.println("The " + a + " compare to " + b + " is " + a.compareTo(b));
                    if (a.equals(b)) {
                        System.out.println("The " + a + " is equals to " + b);
                    } else {
                        System.out.println("The " + a + " is not equals to " + b);
                    }
                }
                input.nextLine(); // Consume the newline left by the input
            }
        }
        input.close();
    }
}

---

二、函数题

1、设计一个矩形类Rectangle

设计一个名为Rectangle的类表示矩形。这个类包括：
两个名为width和height的double型数据域，它们分别表示矩形的宽和高。width和height的默认值都为1.
一个无参构造方法。
一个为width和height指定值的矩形构造方法。
一个名为getArea()的方法返回这个矩形的面积。
一个名为getPerimeter()的方法返回这个矩形的周长。
类名为：
Rectangle
裁判测试程序样例：

import java.util.Scanner;
/* 你的代码将被嵌入到这里 */

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

    double w = input.nextDouble();
    double h = input.nextDouble();
    Rectangle myRectangle = new Rectangle(w, h);
    System.out.println(myRectangle.getArea());
    System.out.println(myRectangle.getPerimeter());

    input.close();
  }
}

输入样例：
3.14 2.78
输出样例：
8.7292
11.84

class Rectangle{
    private double width;
    private double height;

    public Rectangle(){
        this.width = 1;
        this.height = 1;
    }

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getArea() {
        return width * height;
    }

    public double getPerimeter() {
        return 2 * width + 2 * height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
}

2、根据派生类写出基类

裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。

函数接口定义：
提示：
观察派生类代码和main方法中的测试代码，补全缺失的代码。

裁判测试程序样例：
注意：真正的测试程序中使用的数据可能与样例测试程序中不同，但仅按照样例中的格式调用相关方法（函数）。

class People{
    protected String id;
    protected String name;
    
    /** 你提交的代码将被嵌在这里（替换此行） **/
    
}

class Student extends People{
    protected String sid;
    protected int score;
    public Student() {
        name = "Pintia Student";
    }
    public Student(String id, String name, String sid, int score) {
        super(id, name);
        this.sid = sid;
        this.score = score;
    }
    public void say() {
        System.out.println("I'm a student. My name is " + this.name + ".");
    }

}
public class Main {
    public static void main(String[] args) {
        Student zs = new Student();
        zs.setId("370211X");
        zs.setName("Zhang San");
        zs.say();
        System.out.println(zs.getId() + " , " + zs.getName());
        
        Student ls = new Student("330106","Li Si","20183001007",98);
        ls.say();
        System.out.println(ls.getId() + " : " + ls.getName());
        
        People ww = new Student();
        ww.setName("Wang Wu");
        ww.say();
        
        People zl = new People("370202", "Zhao Liu");
        zl.say();
    }
}

输入样例：
在这里给出一组输入。例如：
（无）

输出样例：
在这里给出相应的输出。例如：
I’m a student. My name is Zhang San.
370211X , Zhang San
I’m a student. My name is Li Si.
330106 : Li Si
I’m a student. My name is Wang Wu.
I’m a person! My name is Zhao Liu.

 public People(){
    }
    public People(String id, String name){
        this.id = id;
        this.name = name;
    }
    public String getId(){
        return id;
    }
    public void setId(String id){
        this.id = id;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public void say(){
        System.out.println("I'm a person! My name is " + this.name + ".");
    }

3、写出派生类构造方法

裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。
函数接口定义：

提示：
观察类的定义和main方法中的测试代码，补全缺失的代码。
裁判测试程序样例：

注意：真正的测试程序中使用的数据可能与样例测试程序中不同，但仅按照样例中的格式调用相关方法（函数）。

class People{
    private String id;
    private String name;
    public People(String id, String name) {
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public String getName() {
        return name;
    }
}

class Student extends People{
    private String sid;
    private int score;
    public Student(String id, String name, String sid, int score) {
    
    /** 你提交的代码将被嵌在这里（替换此行） **/
    
    }
    public String toString(){
        return ("(Name:" + this.getName() 
                + "; id:" + this.getId() 
                + "; sid:" + this.sid
                + "; score:" + this.score 
                + ")");
    }

}
public class Main {
    public static void main(String[] args) {
        Student zs = new Student("370202X", "Zhang San", "1052102", 96);
        System.out.println(zs);
        
    }
}

输入样例：
在这里给出一组输入。例如：
（无）

输出样例：
(Name:Zhang San; id:370202X; sid:1052102; score:96)

        super(id, name);
        this.sid = sid;
        this.score = score;

4、从抽象类shape类扩展出一个圆形类Circle

请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。

public abstract class shape {// 抽象类
public abstract double getArea();// 求面积
public abstract double getPerimeter(); // 求周长
}

主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。

圆形类名Circle
裁判测试程序样例：

import java.util.Scanner;
import java.text.DecimalFormat;
 
abstract class shape {// 抽象类
     /* 抽象方法 求面积 */
    public abstract double getArea( );
 
    /* 抽象方法 求周长 */
    public abstract double getPerimeter( );
}

/* 你提交的代码将被嵌入到这里 */

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
         double r = input.nextDouble( ); 
        shape c = new  Circle(r);
 
        System.out.println(d.format(c.getArea()));
        System.out.println(d.format(c.getPerimeter()));
        input.close();
    } 
}

输入样例：
3.1415926

输出样例：
31.0063
19.7392

class Circle extends shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double getArea(){
        return Math.PI * radius * radius;
    }
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

5、创建一个直角三角形类实现IShape接口

创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。
interface IShape {// 接口
public abstract double getArea(); // 抽象方法 求面积
public abstract double getPerimeter(); // 抽象方法 求周长
}

###直角三角形类的定义：
直角三角形类的构造函数原型如下：
RTriangle(double a, double b);
其中 a 和 b 都是直角三角形的两条直角边。

裁判测试程序样例：

import java.util.Scanner;
import java.text.DecimalFormat;
 
interface IShape {
    public abstract double getArea();
 
    public abstract double getPerimeter();
}
 
/*你写的代码将嵌入到这里*/


public class Main {
    public static void main(String[] args) {
        DecimalFormat d = new DecimalFormat("#.####");
        Scanner input = new Scanner(System.in);
        double a = input.nextDouble();
        double b = input.nextDouble();
        IShape r = new RTriangle(a, b);
        System.out.println(d.format(r.getArea()));
        System.out.println(d.format(r.getPerimeter()));
        input.close();
    }
}

输入样例：
3.1 4.2

输出样例：
6.51
12.5202

class RTriangle implements IShape {
    private double a;
    private double b;
    public RTriangle(double a, double b) {
        this.a = a;
        this.b = b;
    }
    @Override
    public double getArea() {
        return a * b * 0.5;
    }
    @Override
    public double getPerimeter() {
        return a + b + Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
    }
}

6、异常-多种类型异常的捕获

如果try块中的代码有可能抛出多种异常，且这些异常之间可能存在继承关系，那么在捕获异常的时候需要注意捕获顺序。
补全下列代码，使得程序正常运行。

裁判测试程序：

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    while (sc.hasNext()) {
        String choice = sc.next();
        try {
            if (choice.equals("number"))
                throw new NumberFormatException();
            else if (choice.equals("illegal")) {
                throw new IllegalArgumentException();
            } else if (choice.equals("except")) {
                throw new Exception();
            } else
            break;
        }
        /*这里放置你的答案*/
    }//end while
    sc.close();
}

输出说明
在catch块中要输出两行信息：
第1行：要输出自定义信息。如下面输出样例的number format exception
第2行：使用System.out.println(e)输出异常信息，e是所产生的异常。

输入样例
number illegal except quit

输出样例
number format exception
java.lang.NumberFormatException
illegal argument exception
java.lang.IllegalArgumentException
other exception
java.lang.Exception

              catch (NumberFormatException e) {
                System.out.println("number format exception");
                System.out.println(e);
            } catch (IllegalArgumentException e) {
                System.out.println("illegal argument exception");
                System.out.println(e);
            } catch (Exception e) {
                System.out.println("other exception");
                System.out.println(e);
            }

7、多线程-Thread

编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。
功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息

裁判测试程序：

import java.util.Scanner;

/*这里放置你的答案，即MyThread类的代码*/

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Thread t1 = new MyThread(Integer.parseInt(sc.next()));
        t1.start();
    }
}

输入样例：
3

输出样例：
0
1
2
标识信息

// MyThread类继承自Thread
class MyThread extends Thread {
    private int n; // 循环次数

    // 构造方法，用于初始化循环次数
    public MyThread(int n) {
        this.n = n;
    }

    // 重写run方法
    @Override
    public void run() {
        for (int i = 0; i < n; i++) {
            System.out.println(i);
        }
        // 打印线程的标识信息和存活状态
        System.out.println(Thread.currentThread().getName() + " " + isAlive());
    }
}

8、多线程-PrintTask

编写PrintTask类实现Runnable接口。
功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。

裁判测试程序：

import java.util.Scanner;

/*这里放置你的答案，即PrintTask类的代码*/

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintTask task = new PrintTask(Integer.parseInt(sc.next()));
        Thread t1 = new Thread(task);
        t1.start();
        sc.close();
    }
}

输入样例：
3

输出样例：
0
1
2
标识信息

class PrintTask implements Runnable {
    private int n;
    public PrintTask(int n) {
        this.n = n;
    }
    @Override
    public void run() {
        for (int i = 0; i < n; i++) {
            System.out.println(i);
        }
        System.out.println(Thread.currentThread().getName());
    }
}

9、学生、大学生、研究生类

定义Student学生类，拥有学号、姓名、性别属性，提供构造函数，以及相应属性的get set函数，提供函数attendClass(String className)表示上课。
定义CollegeStudent大学生类继承自Student类，拥有新增属性专业，提供构造函数，提供新增属性的get和set函数
定义GraduateStudent研究生类继承自CollegeStudent类，拥有新增属性导师，提供构造函数，提供新增属性的get和set函数，提供函数doResearch() 表示做研究（打印xx is doing research）。
main函数中对构造的类进行测试

输入描述：
学生类信息，学号、姓名、性别
大学生类信息，学号、姓名、性别、专业
研究生类信息，学号、姓名、性别、专业、导师

输出描述：
学生类信息
大学生类信息
研究生类信息

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         int no = scan.nextInt();
         String name = scan.next();      
         String sex = scan.next();      
         Student s = new Student(no, name, sex);
         s.print();

         no = scan.nextInt();
         name = scan.next();      
         sex = scan.next();      
         String major = scan.next();
         CollegeStudent c = new CollegeStudent(no, name, sex, major);
         c.print();

         no = scan.nextInt();
         name = scan.next();      
         sex = scan.next();      
         major = scan.next();
         String supervisor = scan.next();
         GraduateStudent g = new GraduateStudent(no, name, sex, major, supervisor );
         g.print();
         g.doResearch();
         scan.close(); 
    }
}

/* 你的代码被嵌在这里*/

输入样例：
在这里给出一组输入。例如：
1 liu female
2 chen female cs
3 li male sc wang

输出样例：
在这里给出相应的输出。例如：
no: 1
name: liu
sex: female
no: 2
name: chen
sex: female
major: cs
no: 3
name: li
sex: male
major: sc
supervisor: wang
li is doing research

class Student{
    private int no;
    private String name;
    private String sex;
    public Student(int no, String name, String sex) {
        this.no = no;
        this.name = name;
        this.sex = sex;
    }
    public Student() {

    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex(){
        return sex;
    }
    public void setSex(){
        this.sex = sex;
    }
    public void print(){
        System.out.println("no: " + no);
        System.out.println("name: " + name);
        System.out.println("sex: " + sex);
    }
}

class CollegeStudent extends Student{
    private String major;
    public CollegeStudent(int no, String name, String sex, String major) {
        super(no, name, sex);
        this.major = major;
    }
    public String getMajor() {
        return major;
    }
    public void setMajor(String major) {
        this.major = major;
    }
    @Override
    public void print() {
        super.print();
        System.out.println("major: " + major);
    }
}

class GraduateStudent extends CollegeStudent{
    private String supervisor;
    public GraduateStudent(int no, String name, String sex, String major, String supervisor) {
        super(no, name, sex, major);
        this.supervisor = supervisor;
    }
    public String getSupervisor() {
        return supervisor;
    }
    public void setSupervisor(String supervisor) {
        this.supervisor = supervisor;
    }
    public void doResearch(){
        System.out.println(getName() + " is doing research");
    }
    @Override
    public void print() {
        super.print();
        System.out.println("supervisor: " + supervisor);
    }
}

10、 Shape类

定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数
定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
在main函数中，分别构造三个子类的对象，并输出他们的周长、面积.
提示：用System.out.printf(“%.2f”,d)进行格式化输出

输入描述：
正方形类的边长
长方形类的长宽
圆类的半径

输出描述：
正方形的周长、面积
长方形的周长、面积

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         double length = scan.nextDouble();
         Square s = new Square(length);
         System.out.printf("%.2f ",s.getPerimeter());
         System.out.printf("%.2f\n",s.getArea());

         length = scan.nextDouble();
         double wide = scan.nextDouble();
         Rectangle r = new Rectangle(length,wide);
         System.out.printf("%.2f ",r.getPerimeter());
         System.out.printf("%.2f\n",r.getArea());

         double radius = scan.nextDouble();
         Circle c = new Circle(radius);
         System.out.printf("%.2f ",c.getPerimeter());
         System.out.printf("%.2f\n",c.getArea());

         scan.close(); 
    }
}

/* 你的代码被嵌在这里 */

输入样例：
在这里给出一组输入。例如：
1
1 2
2
输出样例：
在这里给出相应的输出。例如：
4.00 1.00
6.00 2.00
12.57 12.57

abstract class Shape{
    public abstract double getPerimeter();
    public abstract double getArea();
}
class Square extends Shape{
    private double side;
    public Square(double side){
        this.side = side;
    }
    @Override
    public double getPerimeter() {
        return 4 * side;
    }
    @Override
    public double getArea() {
        return side * side;
    }
}
class Rectangle extends Shape{
    private double length;
    private double width;
    public Rectangle(double length, double width){
        this.length = length;
        this.width = width;
    }
    @Override
    public double getPerimeter() {
        return 2 * (length + width);
    }
    @Override
    public double getArea() {
        return length * width;
    }
}
class Circle extends Shape{
    private double radius;
    public Circle(double radius){
        this.radius = radius;
    }
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

Shape类作为抽象类，为正方形（Square）、长方形（Rectangle，尽管它继承自Square在逻辑上可能不是最佳选择）和圆形（Circle）提供了一个通用的框架。这些子类通过实现getPerimeter()和getArea()方法来提供它们各自特有的周长和面积计算方式。

使用抽象类的好处包括：

1. 代码复用：抽象类可以包含一些通用的、非抽象的方法，这些方法可以在所有子类中复用。例如，Shape类可能包含一些与形状相关的通用方法，这些方法对于所有形状都是相同的。
2. 定义接口：抽象类为子类提供了一个明确的接口（或契约），规定了子类必须实现哪些方法。这有助于确保子类之间的互操作性，因为它们都遵循相同的规则。
3. 安全性：通过将某些方法声明为抽象，可以防止子类意外地覆盖或更改这些方法的行为。这有助于维护代码的完整性和稳定性。
4. 限制实例化：抽象类不能被直接实例化，这可以防止创建没有意义的或未完成的形状对象。只有提供了所有必要实现的子类才能被实例化。

11、长方形长方体类

定义一个长方形类Rectangle，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方体类，拥有长、宽、高属性，提供构造函数，getPerimeter函数计算所有边的周长，getArea函数计算表面积，新增getVolume函数，计算体积
在main函数中，分别构造长方形类和长方体类的对象，并输出他们的周长、面积、体积，保留两位小数

输入描述：
长方形类的长、宽
长方体类的长、宽、高

输出描述：
长方形的周长和面积
长方体的周长，表面积，体积

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
   
         double length = scan.nextDouble();
         double wide = scan.nextDouble();
         Rectangle r = new Rectangle(length,wide);
         System.out.printf("%.2f ",r.getPerimeter());
         System.out.printf("%.2f",r.getArea());
System.out.println();
         length = scan.nextDouble();
         wide = scan.nextDouble();
         double height = scan.nextDouble();
         Cuboid  c = new Cuboid (length, wide, height);
         System.out.printf("%.2f ",c.getPerimeter());
         System.out.printf("%.2f ",c.getArea());
         System.out.printf("%.2f",c.getVolume());

         scan.close(); 
    }
}

/* 你的代码被嵌在这里 */

输入样例：
在这里给出一组输入。例如：
1 2
1 2 3

输出样例：
在这里给出相应的输出。例如：
6.00 2.00
24.00 22.00 6.00

class Rectangle{
    protected double length;
    protected double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    public double getPerimeter() {
        return 2 * (length + width);
    }
    public double getArea() {
        return length * width;
    }
}

class Cuboid extends Rectangle{
    private double height;
    public Cuboid(double length, double width, double height) {
        super(length, width);
        this.height = height;
    }
    public double getPerimeter() {
        return 4 * (length + width + height);
    }

    public double getArea() {
        return 2 * (length * width + width * height + height * length);
    }

    public double getVolume() {
        return length * width * height;
    }
}

在Java编程语言中，protected 访问修饰符是一种类成员（包括字段、方法和构造函数）的访问级别。当一个类成员被标记为 protected 时，它遵循以下访问规则：

1. 同一个包内的访问：

protected 成员可以被同一个包内的任何其他类访问。

2. 子类访问：

无论子类位于哪个包中，它都可以访问其父类中的 protected 成员。这意味着，如果一个类有一个 protected 成员，那么它的所有子类（无论是直接子类还是间接子类）都可以访问这个成员。

3. 不可从类外部直接访问：

protected 成员不能从定义它们的类的外部（既不是同一个包内，也不是子类）直接访问。这意味着，你不能创建一个类的实例，然后通过这个实例来访问它的 protected 成员（除非这个访问发生在同一个包内，或者通过继承关系）。

4. 构造函数的限制：

如果一个类的构造函数被声明为 protected，那么这个类不能在包外被实例化。它只能被同一个包内的其他类实例化，或者被它的子类实例化（即使子类位于不同的包中）。

5. 不应用于顶层类：

protected 修饰符不能用于顶层类（即没有父类的类）。顶层类总是具有包级私有（默认）访问权限或 public 访问权限。

6. 接口中的限制：

在接口中，字段默认是 public static final 的，因此不能使用 protected 修饰符。方法默认是 public abstract 的，同样不能使用 protected。然而，在Java 8及更高版本中，接口可以包含默认方法（使用 default 关键字）和静态方法，这些方法可以是 public 的（默认）或 private 的（从Java 9开始），但不能是 protected 的。

使用 protected 访问修饰符的主要目的是提供一种机制，允许类的子类访问特定的成员，同时限制这些成员对外部世界的可见性。这有助于封装类的内部实现细节，同时保持一定的灵活性，允许子类在必要时覆盖或扩展父类的行为。

12、设计一个BankAccount类

设计一个BankAccount类，这个类包括：
（1）一个int型的balance变量表示账户余额。
（2）一个无参数构造方法，将账户余额初始化为0。
（3）一个带一个参数的构造方法，将账户余额初始化为输入的参数。
（4）一个int型的accountNumber变量表示开户数量，每创建一个BankAccount对象就自动加1。
（5）一个getBalance()方法：返回账户余额。
（6）一个withdraw()方法：带一个int型的amount参数，从账户余额中提取amount指定的款额。
如果amount<0或者大于当前账户余额，则输出“Invalid Amount”。
（7）一个deposit()方法：带一个int型的amount参数，将amount指定的款额存储到该银行账户上。
如果amount<0，则输出“Invalid Amount”。

裁判测试程序样例：

import java.util.Scanner;
/* 请在这里填写答案 */
public class Main {

    public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
          boolean choice1 = scanner.nextBoolean();
           //是否创建对象 
           if (choice1==true)
           {
                //账户1
        BankAccount myAccount1=new BankAccount();
                //账户2
        BankAccount myAccount2=new BankAccount(100);
                //选择操作类型
                int choice2 = scanner.nextInt();
                switch(choice2){
                  case 0://存款
                   int depositAmount=scanner.nextInt();
              myAccount2.deposit(depositAmount);
                     break;
                   case 1://取款
            int withdrawAmount=scanner.nextInt();
              myAccount2.withdraw(withdrawAmount);
                     break;
                }
                
         System.out.println(myAccount2.getBalance());
           }
            
            System.out.println(BankAccount.accountNumber);
            scanner.close();
    }

}

输入样例：
输入1：
true
0 20
输出样例：
120
2

输入样例：
输入2：
true
1 120
输出样例：
输出2：
Invalid Amount
100
2

输入样例：
输入3：
false
输出样例：
输出3：
0

public class BankAccount {
    protected int balance;
    protected static int accountNumber = 0; // 静态变量，用于跟踪开户数量

    // 无参数构造方法，初始化余额为0
    public BankAccount() {
        this.balance = 0;
        accountNumber++; // 每创建一个对象，开户数量加1
    }

    // 带一个参数的构造方法，初始化余额为输入参数
    public BankAccount(int initialBalance) {
        if (initialBalance < 0) {
            throw new IllegalArgumentException("Initial balance cannot be negative.");
        }
        this.balance = initialBalance;
        accountNumber++; // 每创建一个对象，开户数量加1
    }

    // 获取余额的方法
    public int getBalance() {
        return balance;
    }

    // 取款方法
    public void withdraw(int amount) {
        if (amount < 0 || amount > balance) {
            System.out.println("Invalid Amount");
        } else {
            balance -= amount;
        }
    }

    // 存款方法
    public void deposit(int amount) {
        if (amount < 0) {
            System.out.println("Invalid Amount");
        } else {
            balance += amount;
        }
    }

    // 获取开户数量的方法（可选，因为可以直接访问静态变量，但为了封装性，可以提供一个方法）
    public static int getAccountNumber() {
        return accountNumber;
    }
}

13、圆柱体计算

1.构造一个Circle类：
1)该类有一个double型成员变量radius存放半径；
2)该类有一个有参构造方法，为成员变量radius赋值；
3)该类具有getArea和getLength两个方法，能够利用半径和Math.PI计算高精度的面积和周长。

2.构造一个Column类：
1）该类有一个Circle型成员变量bottom为圆柱体的底面；
2）该类有一个double型成员变量height存放圆柱体的高；
3）该类有getBottom和setBottom方法作为成员变量bottom的访问方法和赋值方法；
4）该类有getHeight和setHeight方法作为成员变量height的访问方法和赋值方法；
5）该类有getVolume方法，计算并返回圆柱体的体积。

裁判测试程序样例：

在这里给出函数被调用进行测试的例子。例如：
import java.util.Scanner;
public class Main {
     public static void main(String[] args) {
       Scanner scanner=new Scanner(System.in);      
       double r=scanner.nextDouble();
       double h=scanner.nextDouble();
       Circle c = new Circle(r);
       Column column=new Column();
       column.setBottom(c);
       column.setHeight(h);
       System.out.printf("底面面积和周长分别为：%.2f %.2f\n",column.getBottom().getArea(),column.getBottom().getLength());
       System.out.printf("体积为：%.2f\n",column.getVolume());      
       scanner.close();
   }
}

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

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

输出样例：
在这里给出相应的输出。例如：
底面面积和周长分别为：314.16 62.83
体积为：628.32

class Circle {
    private double radius;

    // 有参构造方法
    public Circle(double radius) {
        this.radius = radius;
    }

    // 计算面积
    public double getArea() {
        return Math.PI * radius * radius;
    }

    // 计算周长
    public double getLength() {
        return 2 * Math.PI * radius;
    }
}

// Column.java
class Column {
    private Circle bottom;
    private double height;

    // Getter 和 Setter 方法
    public Circle getBottom() {
        return bottom;
    }

    public void setBottom(Circle bottom) {
        this.bottom = bottom;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    // 计算体积
    public double getVolume() {
        return bottom.getArea() * height;
    }
}

14、Book类设计

创建一个书籍类：Book类：
（1）string name、 int price的私有成员
（2）包含有参构造方法和无参构造方法
（3）成员方法public void printInfo()

裁判测试程序样例中展示的是测试类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。

裁判测试程序样例：

import java.util.Scanner;

/* 请在这里补充代码 */



public class Main {
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        String name = in.next();
        int price = in.nextInt();
        Book book1 = new Book(name,price);
        
        Book book2 = new Book();
        
        book1.printInfo();
        book2.printInfo();
        
        in.close();

    }

}

输入样例:
C语言程序设计 46

输出样例:
在这里给出相应的输出。例如：
C语言程序设计-46
Java程序设计-54

class Book {
    private String name;
    private int price;
    public Book(String name, int price) {
        this.name = name;
        this.price = price;
    }
    public Book(){
        this.name = "Java程序设计";
        this.price = 54;
    }
    public void printInfo(){
        System.out.println(name + "-" + price);
    }
}

当 printInfo 方法被调用时，它会执行 System.out.println 语句，将 Book 对象的 name 和 price 成员变量的值输出到控制台。由于 name 和 price 是私有成员变量，它们只能通过类内部的方法（如 printInfo）或公共的getter方法（如果提供了的话）来访问。

15、Flower类设计

创建一个花类：Flower类：
（1）String name、String color、double price的私有成员
（2）包含有参构造方法和无参构造方法，其中无参构造方法里的属性值设置为某个默认值（见测试用例）
（3）成员方法public void printInfo()

裁判测试程序样例中展示的是测试类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。

裁判测试程序样例：

import java.util.Scanner;
/* 请在这里补充代码 */
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String name = in.next();
        String color = in.next();
        double price = in.nextDouble();
        Flower flower1 = new Flower(name,color,price);
        Flower flower2 = new Flower();
        flower1.printInfo();
        flower2.printInfo();
        in.close();
    }
}

输入样例:
百合花 白色 108.8

输出样例:
在这里给出相应的输出。例如：
百合花-白色-108.8
玫瑰花-红色-99.9

class Flower{
    protected String name;
    protected String color;
    protected double price;
    public Flower(String name,String color,double price){
        this.name=name;
        this.color=color;
        this.price=price;
    }
    public Flower(){
        this.name = "玫瑰花";
        this.color = "红色";
        this.price = 99.9;
    }
    public void printInfo() {
        System.out.println(name + "-" + color + "-" + price);
    }
}

16、 Person类

构造Person类。包括姓名(name)，性别(sex)和年龄(age)。提供所有属性的set和get函数，提供print函数打印其信息。

输入描述：
姓名(name)，性别(sex)和年龄(age)

输出描述：
用户信息

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         String name = scan.next();      
         String sex = scan.next();      
         int age = scan.nextInt();
         Person p = new Person();
         p.setName(name);
         p.setSex(sex);
         p.setAge(age);
         p.print();
         scan.close(); 
    }
}

/* 你的代码被嵌在这里 */

输入样例：
在这里给出一组输入。例如：
Lucy male 23

输出样例：
在这里给出相应的输出。例如：
name:Lucy; sex:male; age:23

class Person{
    private String name;
    private String sex;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setSex(String sex){
        this.sex = sex;
    }
    public String getSex(){
        return sex;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void print(){
        System.out.println("name:" + name + "; sex:" + sex + "; age:" + age);
    }
}

25、Java类实现-圆

构造一个Circle类，该类有一个私有double变量radius存放半径，可以通过getter/setter方法进行访问。
该类具有getArea和getLength两个方法，能够利用半径和Math.PI计算高精度的面积和周长。

裁判测试程序样例：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNextFloat()){
            double r=scanner.nextDouble();
            Circle c = new Circle(r);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
            c.setRadius(c.getRadius()*2);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
        }
    }
}
/* 请在这里填写答案 */

输入样例：
1
2
3

输出样例：
以输入的浮点数作为半径创建圆型对象，输出圆的面积和周长；将圆的半径修改为原半径的2倍，输出修改后圆的面积和周长。
3.14 6.28
12.57 12.57
12.57 12.57
50.27 25.13
28.27 18.85
113.10 37.70

class Circle {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public double getArea() {
        return Math.PI * radius * radius;
    }
    public double getLength() {
        return 2 * Math.PI * radius;
    }
}

17、设计一个长方体类Cuboid

要求：设计一个名为Cuboid的类表示长方体。这个类包括三个名为length、width和height 的double型数据域，它们分别表示长方体的长、宽和高。
一个无参构造方法, length、width、height的默认值都为1。 一个为length、width、height指定值的构造方法。
一个名为getArea()的方法返回这个长方体的表面积。 一个名为getVolume()的方法返回这个长方体的体积。

函数接口定义：
public double getArea();
public double getVolume();

裁判测试程序样例：

import java.util.Scanner;
/* 你的代码将被嵌入到这里 */

public class Main {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    
    double l = input.nextDouble();
    double w = input.nextDouble();
    double h = input.nextDouble();
    Cuboid myCuboid = new Cuboid(l, w, h);
    System.out.println(myCuboid.getArea());
    System.out.println(myCuboid.getVolume());

    input.close();
  }
}

输入样例：
3.5 2 5

输出样例：
69.0
35.0

class Cuboid {
    private double length;
    private double width;
    private double height;
    public Cuboid(){
        this.length = 1.0;
        this.width = 1.0;
        this.height = 1.0;
    }
    public Cuboid(double length, double width, double height){
        this.length = length;
        this.width = width;
        this.height = height;
    }
    public double getArea(){
        return 2 * (length * width + height * width + length * height);
    }
    public double getVolume(){
        return length * width * height;
    }
}

18 、设计矩形类Rectangle

设计一个名为Rectangle的类表示矩形。这个类包括： 两个名为width和height的int型数据域，它们分别表示矩形的宽和高。width和height的默认值都为10. 一个无参构造方法。 一个为width和height指定值的矩形构造方法。 一个名为getArea()的方法返回这个矩形的面积。 一个名为getPerimeter()的方法返回这个矩形的周长。

裁判测试程序样例：

import java.util.Scanner;

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

    int w = input.nextInt();
    int h = input.nextInt();
        
    Rectangle myRectangle1 = new Rectangle(w, h);
    System.out.println(myRectangle1.getArea());
    System.out.println(myRectangle1.getPerimeter());
    
    Rectangle myRectangle2 = new Rectangle();
    System.out.println(myRectangle2.getArea());
    System.out.println(myRectangle2.getPerimeter());
    input.close();
  }
}

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

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

输出样例：
在这里给出相应的输出。例如：
15
16
100
40

class Rectangle {
    private int width;
    private int height;
    public Rectangle() {
        this.width = 10;
        this.height = 10;
    }
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    public int getArea() {
        return width * height;
    }
    public int getPerimeter() {
        return 2 * (width + height);
    }
}

19、 Animal接口

已知有如下Animal抽象类和IAbility接口，请编写Animal子类Dog类与Cat类，并分别实现IAbility接口，另外再编写一个模拟器类Simulator调用IAbility接口方法，具体要求如下。
已有的Animal抽象类定义：

abstract class Animal{
    private String name;  //名字
    private int age;   //年龄
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }    
}

已有的IAbility接口定义：
interface IAbility{
void showInfo(); //输出动物信息
void cry(); //动物发出叫声
}

需要你编写的Dog子类：
实现IAbility接口
showInfo方法输出Dog的name、age，输出格式样例为：我是一只狗,我的名字是Mike,今年2岁（注意：输出结果中没有空格，逗号为英文标点符号）
cry方法输出Dog 的叫声，输出格式样例为：旺旺

需要你编写的Cat子类：
实现IAbility接口
showInfo方法输出Cat的name、age，输出格式样例为：我是一只猫,我的名字是Anna,今年4岁（注意：输出结果中没有空格，逗号为英文标点符号）
cry方法输出Cat 的叫声，输出格式样例为：喵喵

需要你编写的模拟器类Simulator：
void playSound(IAbility animal)：调用实现了IAbility接口类的showInfo和cry方法，并显示传入动物的名字和年龄

已有的Main类定义：

public class Main {

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        IAbility animal=null;
        int type=input.nextInt();
        String name=input.next();
        int age=input.nextInt();
        if (type==1)
            animal=new Dog(name,age);
        else
            animal=new Cat(name,age);
        
        Simulator sim=new Simulator();
        sim.playSound(animal);
        input.close();
    }
}

/***请在这里填写你编写的Dog类、Cat类和Simulator类** */

输入样例：
(本题的评分点与输入样例无关)
第一个整数代表动物类型，1为狗类，2为猫类
1 Mike 2

输出样例：
我是一只狗,我的名字是Mike,今年2岁
旺旺
Mike
2

class Dog extends Animal implements IAbility{
    public Dog(String name,int age){
        super(name,age);
    }
    public void showInfo(){
        System.out.println("我是一只狗,我的名字是"+getName()+",今年"+getAge()+"岁");
    }
    public void cry(){
        System.out.println("旺旺");
    }
}
class Cat extends Animal implements IAbility{
    public Cat(String name,int age){
        super(name,age);
    }
    public void showInfo(){
        System.out.println("我是一只猫,我的名字是"+getName()+",今年"+getAge()+"岁");
    }
    public void cry(){
        System.out.println("喵喵");
    }
}
class Simulator{
    public void playSound(IAbility animal){
        animal.showInfo();
        animal.cry();
        System.out.println(((Animal)animal).getName());
        System.out.println(((Animal)animal).getAge());
    }
}

20、长方形长方体类

定义一个长方形类Rectangle，拥有长、宽属性，提供构造方法，能够计算周长getPerimeter()和面积getArea() 。
定义一个子类长方体类，拥有长、宽、高属性，提供构造方法，getPerimeter()方法计算所有边的周长，getArea()方法计算表面积，新增getVolume()方法，计算体积。
在main()方法中，分别构造长方形类和长方体类的对象，并输出他们的周长、面积、体积，保留两位小数。

方法接口定义：
double getPerimeter(); //计算周长
double getArea(); //计算面积
double getVolume(); //计算体积

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double length = scan.nextDouble();
        double wide = scan.nextDouble();
        Rectangle r = new Rectangle(length, wide);
        System.out.printf("%.2f ", r.getPerimeter());
        System.out.printf("%.2f", r.getArea());
        System.out.println();
        length = scan.nextDouble();
        wide = scan.nextDouble();
        double height = scan.nextDouble();
        Cuboid c = new Cuboid(length, wide, height);
        System.out.printf("%.2f ", c.getPerimeter());
        System.out.printf("%.2f ", c.getArea());
        System.out.printf("%.2f", c.getVolume());
        scan.close();
    }
}

/* 你的代码被嵌在这里 */

输入描述：
长方形类的长、宽
长方体类的长、宽、高

输出描述：
长方形的周长和面积
长方体的周长，表面积，体积

输入样例：
1 2
1 2 3

输出样例：
6.00 2.00
24.00 22.00 6.00

class Rectangle {
    protected double length;
    protected double width;
 
    // 构造方法
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
 
    // 计算周长
    public double getPerimeter() {
        return 2 * (length + width);
    }
 
    // 计算面积
    public double getArea() {
        return length * width;
    }
}
 
// 定义长方体类，继承自长方形类
class Cuboid extends Rectangle {
    private double height;
 
    // 构造方法
    public Cuboid(double length, double width, double height) {
        super(length, width);
        this.height = height;
    }
 
    // 重写计算周长方法（对于长方体来说，所有边的周长是没有意义的，但为了符合题意还是实现一下）
    @Override
    public double getPerimeter() {
        return 4 * (super.length + super.width + height); // 12条边总和，但一般长方体不讲所有边的周长
    }
 
    // 计算表面积
    public double getArea() {
        return 2 * (super.length * super.width + super.length * height + super.width * height);
    }
 
    // 计算体积
    public double getVolume() {
        return super.length * super.width * height;
    }
}

21、设计Student类

定义一个Student类，表示学生信息。Student类有学号（id，整型）、姓名（name，字符串）、性别（sex，字符型，m表示男性，f表示女性）三个私有数据域；有参构造方法将学号、姓名、性别设置为给定的参数；成员方法display显示学生的信息。
注意，Student类的定义应该这样开始：
class Student {
也就是说，Student类的class前面不要有public。

输入
输入学号、姓名、性别。

输出
输出学号、姓名、性别。

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int id = in.nextInt();
        String name = in.next();
        char sex = in.next().charAt(0);
        Student student = new Student(id, name, sex);
        student.display();
        in.close();
    }
}

// 需要同学们完成部分，Student类
class Student {
    // 数据成员
    // 成员方法
}

输入样例：
1000
Tan
m

输出样例：
1000
Tan
m

class Student {
    private int id;
    private String name;
    private char sex;
    public Student(int id,String name,char sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }
    public void display() {
        System.out.println(id);
        System.out.println(name);
        System.out.println(sex);
    }
}

22、ICompute接口

接口定义如下：

interface ICompute{
// 计算方法
int compute(int a, int b);
}
其中 a 和 b 为整型参数。

完善如下功能：
1.定义4个类：Plus、Subtract、Multiply、Divide，各自实现ICompute接口，完成两个数加减乘除运算。
2.注意除法运算中处理除数为0时返回-1

裁判测试程序样例：

import java.util.Scanner;

interface ICompute{
    int compute(int a, int b);
    
}

/* 请在这里补充代码 */

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        
        Plus plus = new Plus();
        System.out.println(a + "+" + b + "=" + plus.compute(a, b));
        
        Subtract subtract = new Subtract();
        System.out.println(a + "-" + b + "=" + subtract.compute(a, b));
        
        Multiply multiply = new Multiply();
        System.out.println(a + "*" + b + "=" + multiply.compute(a, b));
        
        Divide divide = new Divide();
        System.out.println(a + "/" + b + "=" + divide.compute(a, b));
        
        
        in.close();

    }

}

输入样例1：
3 0

输出样例1：
3+0=3
3-0=3
3*0=0
3/0=-1

输入样例2：
6 3

输出样例2：
6+3=9
6-3=3
6*3=18
6/3=2

class Plus implements ICompute {
    @Override
    public int compute(int a, int b) {
        return a + b;
    }
}
 
class Subtract implements ICompute {
    @Override
    public int compute(int a, int b) {
        return a - b;
    }
}
 
class Multiply implements ICompute {
    @Override
    public int compute(int a, int b) {
        return a * b;
    }
}
 
class Divide implements ICompute {
    @Override
    public int compute(int a, int b) {
        if (b == 0) {
            return -1;
        }
        return a / b;
    }
}

23、Area接口与Perimeter接口

Area接口与Perimeter接口的实现

接口定义如下：

// 面积接口
interface Area {
    double PI = 3.14;

    double calArea();
}

// 周长接口
interface Perimeter {
    double calPerimeter();
}

完善如下功能：
1.定义Circle类实现上述两个接口，包含半径成员变量和构造方法，其中成员变量为私有类型double radius。
2.定义Rectangle类实现上述两个接口，包含长、宽成员变量和构造方法，其中成员变量为私有类型double length、double width。

裁判测试程序样例：

import java.util.Scanner;

interface Area {
    double PI = 3.14;

    double calArea();
}

interface Perimeter {
    double calPerimeter();
}


/* 请在这里补充代码 */

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        double radius = in.nextDouble();
        Circle c1 = new Circle(radius);
        
        double length = in.nextDouble();
        double width = in.nextDouble();
        Rectangle r1 = new Rectangle(length, width);

        System.out.println("c1's perimeter " + c1.calPerimeter());
        System.out.println("c1's rea " + c1.calArea());
        
        System.out.println("r1's perimeter " + r1.calPerimeter());
        System.out.println("r1's rea " + r1.calArea());

        in.close();
    }

}

输入样例1：
4.0
3.0 4.0

输出样例1：
c1’s perimeter 25.12
c1’s rea 50.24
r1’s perimeter 14.0
r1’s rea 12.0

class Circle implements Area,Perimeter {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double calArea() {
        return PI * radius * radius;
    }
    @Override
    public double calPerimeter() {
        return 2 * PI * radius;
    }
}
class Rectangle implements Area,Perimeter{
    private double length;
    private double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    public double calArea() {
        return length * width;
    }
    @Override
    public double calPerimeter() {
        return 2 * (length + width);
    }
}

24、设计Worker类及其子类

设计一个Worker类，有以下方法：
（1）构造方法：带两个输入参数：工人的姓名和小时工资。
（2）小时工资的get/set方法
（3）pay()方法：带一个工作时长输入参数，输出：“Not Implemented”。
接下来设计Worker的子类：HourlyWorker和SalariedWorker。两个子类都重写继承的方法pay()来计算工人的周薪。计时工按实际工时支付每小时工资，超过40小时的超出部分为双倍工资。计薪工人的工资是40小时的工资，不管工作时间是多少。因为与工作时长无关，故SalariedWorker的方法pay()可以不带参数调用。

类框架定义：
设计的类如下框架所示，完成后将该三类提交。

class Worker {
    ……
}

class HourlyWorker extends Worker {
        ……
}
class SalariedWorker extends Worker {
        ……
}

裁判测试程序样例：

import  java.util.Scanner;

//Main测试类
public class Main{
  public static void main(String[] args) {
      Scanner input = new Scanner(System.in);
       Worker w1 = new Worker("Joe",15);
      w1.pay(35);
      SalariedWorker w2 = new SalariedWorker("Sue",14.5);
      w2.pay();
      w2.pay(60);
      HourlyWorker w3 = new HourlyWorker("Dana", 20);
      w3.pay(25);
      w3.setRate(35);   
            int h = input.nextInt();     # 输入小时工的工作时长
      w3.pay(h);      
  }
}

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

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

输出样例：
在这里给出相应的输出。例如：
Not Implemented
580.0
580.0
500.0
875.0

class Worker{
    private String name;
    private double hourlyRate;
    public Worker(String name, double hourlyRate){
        this.name = name;
        this.hourlyRate = hourlyRate;
    }
    public double getRate(){
        return hourlyRate;
    }
    public void setRate(double hourlyRate){
        this.hourlyRate = hourlyRate;
    }
    public void pay(int hours){
        System.out.println("Not Implemented");
    }
}
class HourlyWorker extends Worker{
    public HourlyWorker(String name, double hourlyRate){
        super(name, hourlyRate);
    }
    @Override
    public void pay(int hours){
        double basePay = Math.min(hours, 40) * getRate();
        double overtimePay = Math.max(hours - 40.0, 0) * getRate() * 2;
        double totalPay = basePay + overtimePay;
        System.out.printf("%.1f\n", totalPay);
    }
}
class SalariedWorker extends Worker{
    private double weeklySalary;
    public SalariedWorker(String name, double hourlyRate){
        super(name, hourlyRate);
        this.weeklySalary = hourlyRate * 40;
    }
    public void pay(){
        System.out.printf("%.1f\n", weeklySalary);
    }
    @Override
    public void pay(int hours){
        pay();
    }
}

25、Java类实现-圆

构造一个Circle类，该类有一个私有double变量radius存放半径，可以通过getter/setter方法进行访问。
该类具有getArea和getLength两个方法，能够利用半径和Math.PI计算高精度的面积和周长。

裁判测试程序样例：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNextFloat()){
            double r=scanner.nextDouble();
            Circle c = new Circle(r);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
            c.setRadius(c.getRadius()*2);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
        }
    }
}
/* 请在这里填写答案 */

输入样例：
1
2
3

输出样例：
以输入的浮点数作为半径创建圆型对象，输出圆的面积和周长；将圆的半径修改为原半径的2倍，输出修改后圆的面积和周长。
3.14 6.28
12.57 12.57
12.57 12.57
50.27 25.13
28.27 18.85
113.10 37.70

提示
应提交的代码类似如下：

class Circle {
    private .......;    

    public Circle(double r){
        .......
    } 

    public double getRadius(){
        .......
    }
 
    public void setRadius(double radius){
        .......
    }
 
    public double getArea() {   
        .......
    }
 
    public double getLength(){
        .......
    } 
};

class Circle {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public double getArea() {
        return Math.PI * radius * radius;
    }
    public double getLength() {
        return 2 * Math.PI * radius;
    }
}

26、Java类实现-正方形

构造一个Square类，该类有一个私有double变量side存放边长，可以通过getter/setter方法进行访问。
该类具有getArea和getLength两个方法，能够利用边长计算正方形的面积和周长。

裁判测试程序样例：

import java.util.Scanner;
public class Main {
 
  public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNextFloat()){
            double s=scanner.nextDouble();
            Square c = new Square(s);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
            c.setSide(c.getSide()*2);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());           
        }
    } 
} 

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

输入样例：
1
2
3

输出样例：
以输入的浮点数作为边长创建正方型对象，输出正方型的面积和周长；将正方形的边长修改为原边长的2倍，输出修改后正方形的面积和周长。
1.00 4.00
4.00 8.00
4.00 8.00
16.00 16.00
9.00 12.00
36.00 24.00

class Square {
    private double side;
    public Square(double side) {
        this.side = side;
    }
    public double getSide() {
        return side;
    }
    public void setSide(double side) {
        this.side = side;
    }
    public double getArea() {
        return side * side;
    }
    public double getLength() {
        return 4 * side;
    }
}

27、Java类实现-小狗类

构造一个Puppy类，该类有一个age变量保存年龄，name变量存放名字，逻辑类型的变量male表示性别（true表示性别为male，否则为female），可以通过getter方法进行访问。该类具有setAge、getAge、getName和isMale方法。

请阅读和分析裁判测试程序样例和输入输出样例，完成Puppy类的代码。

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner myScan = new Scanner(System.in);
        String strName = myScan.next();
        String sex = myScan.next();
        Puppy myPuppy = new Puppy(strName, sex.equals("male"));
        // 通过方法来设定age
        myPuppy.setAge(myScan.nextShort());
        // 调用方法获取 age
        System.out.println("Puppy's age is : " + myPuppy.getAge());
        //调用方法获取 name
        System.out.println("Puppy's name is : " + myPuppy.getName());
        //调用方法获取性别
        System.out.println("Puppy's sex is : " + (myPuppy.isMale() ? "male" : "female"));
    }
}
/* 请在这里填写答案 */

输入样例：
wangzai male 2

输出样例：
Puppy’s age is : 2
Puppy’s name is : wangzai
Puppy’s sex is : male

class Puppy {
    private short age;
    private String name;
    private boolean male;
    public Puppy(String name, boolean male) {
        this.name = name;
        this.male = male;
    }
    public void setAge(short age) {
        this.age = age;
    }
    public short getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    public boolean isMale() {
        return male;
    }
}

在Java中，选择数据类型通常基于几个因素：存储需求、内存效率、以及值的范围。对于age这个属性，它表示的是年龄，通常人类的年龄不会超过一个相对较小的范围（例如，从0到120岁左右）。因此，使用比int更小的数据类型short可以节省内存。

这里是几个选择short而不是其他类型的原因：

1. 内存效率：short类型占用2个字节（16位），而int类型占用4个字节（32位）。如果程序中创建了大量的Puppy对象，并且每个对象都包含一个age属性，那么使用short而不是int可以显著减少内存的使用。
2. 值的范围：short类型的取值范围是-32,768到32,767，这对于表示年龄来说足够了。即使考虑到未来可能的年龄增长（尽管这在现实中不太可能），这个范围也足够大。
3. 代码清晰度：使用short可以明确表明这个属性不需要int所提供的完整范围。这有助于其他开发者理解代码的意图，并可能促使他们在其他地方也做出类似的内存优化决策。
4. 习惯和传统：在某些编程习惯和传统中，对于已知的小范围值，使用较小的数据类型是一种好习惯。这有助于培养对内存使用的敏感性和意识。

然而，值得注意的是，对于单个对象或少量对象来说，这种内存节省可能是微不足道的。但在大型应用程序中，特别是那些需要处理大量数据的应用程序中，这种节省可能会变得显著。

28、汪星人和喵星人

小王和小苗分别是一只可爱的狗狗和猫猫，它们都属于哺乳动物(Mammal)，性格非常活跃，并对自己的名字都很在意并感到自豪，同时，为了显示存在感，它们还经常发出一些噪音。
请编写一个抽象类Mammal和接口CanJump，并定义一个Dog类，该类继承自Mammal，并实现了CanJump接口。

注意分析以下main方法和输入输出样例，以确定Mammal类和CanJump接口的成员变量和成员方法，以及Dog类的方法该如何实现。

裁判测试程序样例：

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name1 = sc.next();
        Dog wang = new Dog(name1);
        wang.makeSound();
        if (wang instanceof CanJump) //如果dog对象所在类实现了CanJump接口，则调用jump()方法
            wang.jump();
        Mammal miao = new Mammal() { //匿名类，类中实现了makeSound()方法
            void makeSound() {
                System.out.println(getName() + ":喵喵喵!");
            }
        };
        String name2 = sc.next();
        miao.setName(name2);
        miao.makeSound();
    }
}

输入样例：
quanquan
weiwei

输出样例：
quanquan:汪汪汪!
quanquan can jump high!
weiwei:喵喵喵!

import java.util.Scanner;

abstract class Mammal {
    protected String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    abstract void makeSound();
}
interface CanJump {
    void jump();
}
class Dog extends Mammal implements CanJump {
    Dog(String name) {
        this.name = name;
    }
    @Override
    void makeSound() {
        System.out.println(name + ":汪汪汪!");
    }
    
    @Override
    public void jump() {
        System.out.println(name + " can jump high!");
    }
}

29、sdut-oop-3-矩形类的设计

设计一个名为Rectangle的类表示矩形。这个类包括：
（1）2个属性：width和height，均为double数据类型，分别表示矩形的长和宽。
（2）无参构造方法，width和height的默认值都为1 。
（3）带参构造方法：width和height指定值的矩形的初始长和宽。
（4）方法getArea()，返回矩形的面积，保留2位小数。
（5）方法getPerimeter()，返回矩形的周长，保留2位小数。
提示：在JAVA中，String.format(“%.2f”, 123.456) 方法可以将123.456转换成字符串对象，其值为：123.46（保留2位小数的字符串）

函数接口定义：

class Rectangle{
}

裁判测试程序样例：
在这里给出函数被调用进行测试的例子。例如：

import java.util.Scanner;

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

    double w = input.nextDouble();
    double h = input.nextDouble();
    Rectangle myRectangle = new Rectangle(w, h);
    System.out.println(myRectangle.getArea());
    System.out.println(myRectangle.getPerimeter());

    input.close();
  }
}
/* 请在这里填写答案 */

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

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

class Rectangle {
    private double width;
    private double height;
    public Rectangle(){
        this.width = 1;
        this.height = 1;
    }
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    public String getArea() {
        return String.format("%.2f", width * height);
    }
    public String getPerimeter() {
        return String.format("%.2f", 2 * width + 2 * height);
    }
}

30、Java中子父类的定义

本题要求定义父类Vehicle和子类Car。
函数接口定义：

class Vehicle
{
}

class Car 继承 Vehicle
{
}
设计一个普通交通工具类Vehicle

其私有属性包括
双精度的速度speed、字符串类型的kind、字符串类型的颜色color；
公共方法包括设置速度、设置颜色、获取类别、获取颜色。
构造方法
空参构造
3个属性赋初值的有参构造
设计一个小车类Car，继承自Vehicle

Car中增加了属性：
座位数passenger，
增加了设置setPassenger()和获取座位数getPassenger()的方法。

打印显示所有Car对象的属性的公共的无返回值的方法print(Car c1)
System.out.println(c1.GetKind() + “的速度是：” + c1.GetSpeed() + “km/h, 颜色是：” + c1.GetColor() + “色, 座位数是 ：” + c1.getPassenger() + “个。”);

测试Main类（已给出）
空参构造创建Car的对象，为其设置新速度和颜色，并显示其状态（所有属性）。

裁判测试程序样例：

public class Main
{
    public static void main(String[] args)
    {
        Car car = new Car();
        car.SetKind("BMW");
        car.SetSpeed(300);
        car.SetColor("white");
        car.setPassenger(7);
        car.print(car);
        Car c = new Car(100,"BenZi","Blace",5);
    c.print(c);
    }
}

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

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

输出样例：
在这里给出相应的输出。例如：
BMW的速度是：300.0km/h, 颜色是：white色, 座位数是 ：7个。
BenZi的速度是：100.0km/h, 颜色是：Blace色, 座位数是 ：5个。

class Vehicle {
    private double speed;
    private String kind;
    private String color;

    public void SetSpeed(double speed) {
        this.speed = speed;
    }

    public double GetSpeed() {
        return speed;
    }

    public void SetKind(String kind) {
        this.kind = kind;
    }

    public String GetKind() {
        return kind;
    }

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

    public String GetColor() {
        return color;
    }

    public Vehicle() {
    }

    public Vehicle(double speed, String kind, String color) {
        this.speed = speed;
        this.kind = kind;
        this.color = color;
    }
}

class Car extends Vehicle {
    private int passenger;

    public void setPassenger(int passenger) {
        this.passenger = passenger;
    }

    public int getPassenger() {
        return passenger;
    }

    public Car() {
        super();
    }

    public Car(double speed, String kind, String color, int passenger) {
        super(speed, kind, color);
        this.passenger = passenger;
    }
    public static void print(Car c1) {
        System.out.println(c1.GetKind() + "的速度是：" + c1.GetSpeed() + "km/h, 颜色是：" + c1.GetColor() + "色, 座位数是 ：" + c1.getPassenger() + "个。");
    }
}

31、Rectangle类

构造一个Rectangle类表示矩形 ， 该类实现了Comparable接口。
该类有两个私有的double型成员变量width和height，表示矩形的宽度和高度；
该类有一个带一个无参的构造方法，把宽带和高度都初始化为0；
该类有一个带两个double型参数的构造方法，用参数的值初始化矩形的宽度和高度。
为width和height添加getter()和setter()方法。注意，宽度和高度必须大于等于0，如果setWidth(double width)方法的参数小于0时，抛出一个IllegalArgumentException异常对象，异常对象的成员变量message为"矩形的宽度必须大于等于0"；setHeight(double height)方法的参数小于0时，抛出一个IllegalArgumentException异常对象，异常对象的成员变量message为"矩形的高度必须大于等于0"。
getArea()方法，返回矩形的面积；
getgetPerimeter()方法，返回矩形的周长；
该类有一个公共的方法int compareTo(Rectangle rectangle)，比较当前对象和参数。如果当前对象的面积大于参数的面积，返回1；当前对象的面积小于参数的面积，返回-1；否则返回0。
该类有一个公共方法toString()，根据矩形的宽度和高度生成并返回一个字符串（具体要求看输出样例）。
构造一个Main ，执行一个for循环，共循环6次。每次循环从键盘读入数据创建两个矩形对象，比较并输出其中较大的对象的面积；如果捕捉到异常，则输出异常信息。

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        for(int i=0; i<6; i++) {
            try{
                Rectangle rectangle1 = new Rectangle(input.nextDouble(), input.nextDouble());
                Rectangle rectangle2 = new Rectangle(input.nextDouble(), input.nextDouble());
                Rectangle maxRectangle;
                if (rectangle1.compareTo(rectangle2)>= 0)
                    maxRectangle = rectangle1;
                else
                    maxRectangle = rectangle2;
                System.out.println("The max area of " + rectangle1 + " and " + rectangle2 + " is " + maxRectangle.getArea());
            } catch (IllegalArgumentException e1) {
                System.out.println(e1.getMessage());
                input.nextLine();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
                input.nextLine();
            }
        }
    }
}
/* 请在这里填写答案 */

输入样例：
-1 1 1 1
1 -1 1 1
1 1 -1 1
1 1 1 -1
3 4 2 5
3 4 2 7

输出样例：
矩形的宽度必须大于等于0
矩形的高度必须大于等于0
矩形的宽度必须大于等于0
矩形的高度必须大于等于0
The max area of Rectangle(width:3.0,height:4.0) and Rectangle(width:2.0,height:5.0) is 12.0
The max area of Rectangle(width:3.0,height:4.0) and Rectangle(width:2.0,height:7.0) is 14.0

class Rectangle implements Comparable<Rectangle>{
    private double width;
    private double height;
    public Rectangle(){
        this.width = 0;
        this.height = 0;
    }
    public Rectangle(double width, double height){
        if(width < 0) throw new IllegalArgumentException("矩形的宽度必须大于等于0");
        if(height < 0) throw new IllegalArgumentException("矩形的高度必须大于等于0");
        this.width = width;
        this.height = height;
    }
    public double getWidth() {
        if(width < 0) throw new IllegalArgumentException("矩形的宽度必须大于等于0");
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        if(height < 0) throw new IllegalArgumentException("矩形的高度必须大于等于0");
        this.height = height;
    }
    public double getArea() {
        return width * height;
    }
    public double getPerimeter() {
        return 2 * (width + height);
    }
    @Override
    public int compareTo(Rectangle rectangle) {
        double thisArea = this.getArea();
        double otherArea = rectangle.getArea();
        if(thisArea < otherArea) return -1;
        if(thisArea > otherArea) return 1;
        return 0;
    }
    @Override
    public String toString() {
        return "Rectangle(width:" + width + ",height:" + height + ")";
    }
}

32、定义学生类

定义一个学生类（Student），其中包括四个属性：姓名（name），年龄（age），班级号（classNo），爱好（hobby）
裁判测试程序样例：

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


测试该类的程序如下：
public class Main {
    public static void main(String args[]){
        Student student = new Student();    
        student.name = "张浩";        
        student.age = 10;
        student.classNo = "S1班";
        student.hobby = "篮球";
        student.show();                           
    }
}

输入样例：
无

输出样例：
姓名：张浩
年龄：10
就读于：S1班
爱好：篮球

class Student{
    public String name;
    public int age;
    public String classNo;
    public String hobby;

    public void show(){
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("就读于：" + classNo);
        System.out.println("爱好：" + hobby);
    }
}

33、定义游客类

定义游客类(其测试类已给出)，要求如下：
一个景区根据游人的年龄收取不同价格的门票。请编写游客类，根据年龄段决定能够购买的门票价格并输出
当输入的年龄小于18或者大于60（不包括18,60）时，程序输出：
年龄为：XX，免费
当输入的年龄在18与60之间时，程序输出
年龄为：XX，价格为20元
裁判测试程序样例：

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

//使用该类创建使用对象的测试类如下：
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Tourist v = new Tourist();        
        v.age = input.nextInt();        
        v.show(); 
    }
}

输入样例1：
18

输出样例1：
年龄为：18，价格为20元

输入样例2：
15

输出样例2：
年龄为：15，免费

class Tourist {
    int age;
    void show(){
        if (age < 18 || age > 60) {
            System.out.println("年龄为：" + age + "，免费");
        } else {
            System.out.println("年龄为：" + age + "，价格为20元");
        }
    }
}

34、定义管理员类

定义一个系统管理员，其中包括两个属性：姓名（name），密码（password，初始值设置为“123456”），一个方法（login）用于判断用户输入的密码是否正确。

裁判测试程序样例：

/* 请在这里填写答案 */
//在这里给出函数被调用进行测试的例子。例如：
public class TestAdmin {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String name=sc.next();
        Admin ad1=new Admin();
        ad1.name=name;
        String pw=sc.next();
        ad1.login(pw);
    }
}

输入样例1：
张三
123456

输出样例1：
密码正确，欢迎张三登录系统

输入样例2：
李四
654321

输出样例2：
密码错误，李四您无权登录系统

class Admin{
    String name;
    String password = "123456";
    void login(String inputPassword){
        if(inputPassword.equals(password)){
            System.out.println("密码正确，欢迎" + name + "登录系统");
        } else {
            System.out.println("密码错误，" + name + "您无权登录系统");
        }
    }
}

35、快递计价器

现需要编写一个简易快递计价程序。具体来说：
1、抽象快递类Express，其包含一个属性int weight表示快递重量（单位为kg），一个方法getWeight()用于返回快递重量和一个抽象方法getTotal()用于计算快递运费。
2、两个类继承Express，分别是：
（a）顺路快递SLExpress：计价规则为首重(1kg)12元，每增加1kg费用加2元。
（b）地地快递DDExpress：计价规则为首重(1kg)5元，每增加1kg费用加1元。
3、菜菜驿站类CaicaiStation，提供静态方法 int calculate(Express[] ex) 用于计算所有快递的费用。

输入样例:
6
SL 2
DD 2
SL 1
SL 1
SL 1
DD 3

输入解释:
第1行n表示需要计算的快递件数
第2至n+1表示每个快递信息，即选哪家快递公司 以及快递的重量（单位kg）

输出样例:
63

输出解释:
所有快递总运费。

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Express[] ex = new Express[n];
        for (int i = 0; i < ex.length; i++) {
            if (sc.next().equals("SL"))
                ex[i] = new SLExpress(sc.nextInt());
            else
                ex[i] = new DDExpress(sc.nextInt());
        }

        System.out.println(CaicaiStation.calculate(ex));
        sc.close();
    }
}
/* 请在这里填写答案 */

abstract class Express {
    protected int weight;
    public Express(int weight) {
        this.weight = weight;
    }
    public int getWeight() {
        return weight;
    }
    public abstract int getTotal();
}
class SLExpress extends Express {
    public SLExpress(int weight) {
        super(weight);
    }
    @Override
    public int getTotal() {
        if(weight <=1 ){
            return 12;
        }else{
            return 12 + (weight - 1) * 2;
        }
    }
}
class DDExpress extends Express {
    public DDExpress(int weight) {
        super(weight);
    }
    @Override
    public int getTotal() {
        if(weight <=1 ){
            return 5;
        }else{
            return 5 + (weight - 1) * 1;
        }
    }
}
class CaicaiStation {
    public static int calculate(Express[] ex) {
        int totalCost = 0;
        for (Express express : ex) {
            totalCost += express.getTotal();
        }
        return totalCost;
    }
}

---

三、 编程题

1、学生类-构造函数

定义一个有关学生的Student类，内含类成员变量
String name、String sex、int age，所有的变量必须为私有(private)。
1.编写有参构造函数：
能对name,sex,age赋值。
2.覆盖toString函数：
按照格式：类名 [name=, sex=, age=]输出。使用idea自动生成,然后在修改成该输出格式
3.对每个属性生成setter/getter方法
4.main方法中
输入1行name age sex , 调用上面的有参构造函数新建对象。
输入样例:
tom 15 male
输出样例:
Student [name=‘tom’, sex=‘male’, age=15]

import java.util.Scanner;

class Student{
    private String name;
    private String sex;
    private int age;

    @Override
    public String toString() {
        String str="Student [name='"+name+"', sex='"+sex+"', age="+age+"]";
        return str;
    }

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public Student() {
    }

    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 getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String name=sc.next();
        int age=Integer.valueOf(sc.next());
        String sex=sc.next();
        Student student = new Student(name, sex, age);
        System.out.println(student);
    }
}

‌@Override注解在Java中用于标记一个方法是要重写父类(或接口)中的方法。它是一种编译器级别的检查，用于确保被注解的方法实际上是重写了父类中的方法。如果被注解的方法没有正确地重写父类的方法，编译器将产生一个错误‌。

2、接口–四则计算器

利用接口做参数，写个计算器，能完成加减乘除运算。
定义一个接口ICompute含有一个方法int computer(int n, int m)。
定义Add类实现接口ICompute，实现computer方法，求m，n之和
定义Sub类实现接口ICompute，实现computer方法，求n-m之差
定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。

输入格式:
输入在一行中给出2个整数

输出格式:
输出两个数的和、差

输入样例:
在这里给出一组输入。例如：
6 7

输出样例:
在这里给出相应的输出。例如：
13
-1

// 导入Scanner类，用于从控制台读取输入
import java.util.Scanner;

// 定义Main类，程序的入口点
public class Main {

    // main方法，程序的执行开始点
    public static void main(String[] args) {
        // 创建Scanner对象，用于从标准输入流（通常是键盘）读取数据
        Scanner in = new Scanner(System.in);
        
        // 从控制台读取第一个整数并赋值给变量n
        int n = in.nextInt();
        
        // 从控制台读取第二个整数并赋值给变量m
        int m = in.nextInt();
        
        // 创建Add对象，用于计算加法
        Add l = new Add();
        
        // 创建Sub对象，用于计算减法
        Sub j = new Sub();
        
        // 调用Add对象的computer方法计算n和m的和，并打印结果
        System.out.println(l.computer(n, m));
        
        // 调用Sub对象的computer方法计算n和m的差，并打印结果
        System.out.println(j.computer(n, m));
        
        // 关闭Scanner对象，释放与之关联的资源
        in.close();
    }
}

// 定义一个接口IComputer，它规定了一个名为computer的方法，该方法接收两个整数参数并返回一个整数结果
interface IComputer {
    // 声明一个抽象方法computer，该方法需要在实现类中具体实现
    abstract public int computer(int n, int m);
}

// 定义一个类Add，它实现了IComputer接口
class Add implements IComputer {
    // 虽然在这里声明了m和n两个变量，但在computer方法内部并没有使用它们
    // 这是因为computer方法的参数已经提供了所需的输入值
    int m, n;
    
    // 实现IComputer接口中的computer方法，用于计算两个整数的和
    public int computer(int n, int m) {
        return n + m; // 返回n和m的和
    }
}

// 定义一个类Sub，它也实现了IComputer接口
class Sub implements IComputer {
    // 与Add类类似，这里的m和n变量并没有被使用
    int m, n;
    
    // 实现IComputer接口中的computer方法，用于计算两个整数的差
    public int computer(int n, int m) {
        return n - m; // 返回n和m的差
    }
}

3、找到出勤最多的人

根据教师的花名册，找到出勤最多的人。
输入格式:
出勤记录单行给出，数据直接使用空格分割。
输出格式:
单行输出（若有多人，人名直接使用空格分割，结尾处没有空格）。
输入样例:
在这里给出一组输入。例如：
zs ls ww ml zs ls ml zs ww
输出样例:
在这里给出相应的输出。例如：
zs

import java.util.*;
 
public class Main {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine(); // 从输入中读取一行字符串
        String[] names = name.split("\\s+"); // 将字符串按照空格或多个空格进行分割，得到一个字符串数组
        HashMap<String, Integer> students = new HashMap<String, Integer>(); // 创建一个HashMap用于存储学生名字和出现次数
 
        // 使用foreach循环遍历names数组，以name为key，以其出现次数为value，将其存入students中
        for (String namestring : names) {
            // students.getOrDefault(namestring, 0)表示当HashMap students中没有该namestring时，返回0；若有则返回其value
            // 最后+1表示又被点到一次，将其放入students中
            students.put(namestring, students.getOrDefault(namestring, 0) + 1);
        }
 
        // 调用Collections类中的max()方法找到students.values()返回的集合中的最大值
        int max = Collections.max(students.values());
 
        List<String> maxname = new ArrayList<String>(); // 创建一个列表用于存储出现次数最多的学生名字
 
        // 使用foreach循环遍历students的键值对集合entrySet
        for (Map.Entry<String, Integer> entry : students.entrySet()) {
            if (entry.getValue() == max) {
                maxname.add(entry.getKey()); // 如果某个学生的出现次数等于最大值，将其名字添加到maxname列表中
            }
        }
 
        Iterator<String> iterator = maxname.iterator(); // 创建一个迭代器用于遍历maxname列表
        int j = 0;
        while (iterator.hasNext()) {
            if (j == 0) {
                System.out.print(iterator.next()); // 如果是第一个学生名字，直接输出
                j = 1;
            } else {
                System.out.print(" " + iterator.next()); // 如果不是第一个学生名字，在前面加上空格后输出
            }
        }
 
    }
 
}

4、USB接口的定义

5、Circle类

a 定义圆类Circle，其中包括：
成员变量定义 private int radius
方法定义 包括下列要求
定义无参构造方法 ，给radius赋值为2，并添加语句System.out.println(“this is a constructor”);
定义有参构造方法 ，接收用户给给radius赋值，如果用户输入半径为<=0,则让半径的值为2，并添加语句System.out.println(“this is a constructor with para”);
为radius半径添加setter方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2
为radius半径添加getter方法，返回用户输入的半径
定义求面积方法public int gerArea(),π使用Math.PI代替，面积的结果强制转换为int返回
定义toString方法，public String toString( )方法体为：
return “Circle [radius=” + radius + “]”;
b定义Main类，在main方法中，完成下列操作
.定义并创建Circle的第一个对象c1，并使用println方法输出c1
求c1的面积并输出
定义并创建Circle的第一个对象c2，并使用println方法输出c2
从键盘接收整数半径，并赋值给c2的半径，使用println方法输出c2
求c2的面积并输出
从键盘接收整数半径，并创建Circle的第三个对象c3，并将用户输入整数半径通过有参构造方法传递给出c3，使用println方法输出c3
求c3的面积并输出
输入格式: 从键盘输入一个整数半径
输出格式:
分别输出c1和c2对象的信息
输入样例:
在这里给出一组输入。例如：
4
5
-4
-2
输出样例:
在这里给出相应的输出。例如：
this is a constructor
Circle [radius=2]
c1:area=12
this is a constructor
Circle [radius=2]
Circle [radius=4]
c2:area=50
this is a constructor with para
Circle [radius=5]
c3:area=78
this is a constructor
Circle [radius=2]
c1:area=12
this is a constructor
Circle [radius=2]
Circle [radius=2]
c2:area=12
this is a constructor with para
Circle [radius=2]
c3:area=12

import java.util.Scanner;

class Circle{
    private int radius;

    public Circle() {
        this.radius = 2;
        System.out.println("this is a constructor");
    }

    public Circle(int radius) {
        if(radius<=0){
            this.radius = 2;
        }else{
            this.radius = radius;
        }
        System.out.println("this is a constructor with para");

    }
    public int getArea(){
        return (int)(this.radius*this.radius*Math.PI);
    }

    @Override
    public String toString() {
        return "Circle [radius="+radius+"]";
    }

    public int getRadius() {
        return radius;
    }

    public void setRadius(int radius) {
        if(radius<=0){
            this.radius = 2;
        }else{
            this.radius = radius;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        System.out.println(c1);
        System.out.println("c1:area="+c1.getArea());
        Circle c2 = new Circle();
        System.out.println(c2);
        Scanner sc = new Scanner(System.in);
        c2.setRadius(sc.nextInt());
        System.out.println(c2);
        System.out.println("c2:area="+c2.getArea());
        Circle c3 = new Circle(sc.nextInt());
        System.out.println(c3);
        System.out.println("c3:area="+c3.getArea());
    }
}

6、 圆柱体类设计

定义一个圆柱类Cylinder
里面包含私有属性 private int radius（半径）,height(高）
为属性完成其setter getter方法
完成带参构造方法Cylinder(int radius,height),该方法中包含一句System.out.println(“Constructor with para”);
完成无参构造方法Cylinder()，在无参构造方法中调用有参构造方法，为半径和高赋值为2,1,该方法包含一句System.out.println(“Constructor no para”);
完成求体积方法 public int getVolumn(){} 求圆柱体积,π使用Math.PI
定义测试类Main，在main方法中，按照顺序要求完成下列操作
从键盘接收两个数，第一个为半径，第二个为高，并利用刚才输出两个数创建圆柱体对象c1,求c1的体积并输出。
使用无参构造方法 创建第二个圆柱体对象c2，求c2的体积并输出。
输入格式:
在一行中输入半径 和高。
输出格式:
对每一个圆柱体输出它的体积
输入样例:
在这里给出一组输入。例如：
2 3
输出样例:
在这里给出相应的输出。例如：
Constructor with para
37
Constructor with para
Constructor no para
12

import java.util.Scanner;

class Cylinder {
    private int radius;
    private int height;

    public void setRadius(int radius) {
        this.radius = radius;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getRadius() {
        return radius;
    }

    public int getHeight() {
        return height;
    }

    public Cylinder(int radius, int height) {
        this.radius = radius;
        this.height = height;
        System.out.println("Constructor with para");
    }

    public Cylinder() {
        this(2, 1);
        System.out.println("Constructor no para");
    }

    public int getVolume() {
        return (int) (Math.PI * radius * radius * height);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int radius = scanner.nextInt();
        int height = scanner.nextInt();

        Cylinder c1 = new Cylinder(radius, height);
        System.out.println(c1.getVolume());
        
        Cylinder c2 = new Cylinder();
        System.out.println(c2.getVolume());

        scanner.close();
    }
}

7、List的使用

8、教师类

设计一个教师类Teacher,要求：
属性有编号（int no）、姓名（String name）、年龄（int age）、所属学院（String seminary），为这些属性设置相应的get和set方法。
为Teacher类重写equals方法，要求：当两个教师对象的no相同时返回true。
重写Teacher类的toString方法，通过该方法可以返回“no: , name:, age: , seminary: ”形式的字符串。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Teacher[] teachers = new Teacher[2];
        for (int i = 0; i < 2; i++) {
            int no = sc.nextInt();
            String name = sc.next();
            int age = sc.nextInt();
            String sem = sc.next();
            teachers[i] = new Teacher(no, name, age, sem);
            System.out.println(teachers[i].toString());
        }
        System.out.println(teachers[0].equals(teachers[1]));
    }
}

class Teacher {
    private int no;
    private String name;
    private int age;
    private String seminary;

    public Teacher() {
    }

    @Override
    public boolean equals(Object obj) {
        Teacher t = (Teacher) obj;
        if (this.no == t.no) return true;
        return false;
    }

    @Override
    public String toString() {
        return "no: " + this.no + ", name:" + this.name +
                ", age: " + this.age + ", seminary: " + this.seminary + "";
    }

    public Teacher(int no, String name, int age, String seminary) {
        this.no = no;
        this.name = name;
        this.age = age;
        this.seminary = seminary;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSeminary() {
        return seminary;
    }

    public void setSeminary(String seminary) {
        this.seminary = seminary;
    }
}

9、正方形类

定义一个正方形类square，在次类中包括写内容：
定义成员变量边长private int edge;
定义方法：包括构造方法，setter getter方法，求面积方法等，要求如下所示：
定义正方形类的构造方法：在构造方法中给edge赋值为2，并添加System.out.println(“this is constructor method”);
为成员变量edge设置set方法，用来接收用户给edge的值，如果用户给的值<=0,则设置edge值为1
为成员变量edge设置get方法，用来返回edge的值
完成求面积方法，得到正方形的面积：public int getArea()
定义类Main，并在main方法中， 1.首先创建正方形对象s1，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
2.创建正方形对象s2,并通过键盘输入s2对象的边的值，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
输入格式:
输入在一行中给出边的值。
输出格式:
输出s1对象的边、输出s1对象的面积
输出s2对象的边、s2对象的面积
输入样例:
在这里给出一组输入。例如：
3
-5
输出样例:
在这里给出相应的输出。例如：
this is constructor method
s1:edge=2
s1:area=4
this is constructor method
s2:edge=3
s2:area=9
this is constructor method
s1:edge=2
s1:area=4
this is constructor method
s2:edge=1
s2:area=1

import java.util.Scanner;

class Square {
    private int edge;
    public Square() {
        edge = 2;
        System.out.println("this is constructor method");
    }
    public void setEdge(int edge) {
        if (edge <= 0) {
            this.edge = 1;
        } else {
            this.edge = edge;
        }
    }
    public int getEdge() {
        return edge;
    }
    public int getArea() {
        return edge * edge;
    }
}

public class Main {
    public static void main(String[] args) {
        Square s1 = new Square();
        System.out.println("s1:edge=" + s1.getEdge());
        System.out.println("s1:area=" + s1.getArea());
        Scanner scanner = new Scanner(System.in);
        int inputEdge = scanner.nextInt();
        Square s2 = new Square();
        s2.setEdge(inputEdge);
        System.out.println("s2:edge=" + s2.getEdge());
        System.out.println("s2:area=" + s2.getArea());
        scanner.close();
    }
}

11、学生类设计

设计一个类Student，并在Main类中生成Student类对象进行测试
1.对于Student类，设计私有属性name和age，并为每一个成员变量name和age设计其setXXX（）和getXXX（）方法,并对于setAge方法，如果age被赋值为<=6,则age值为7，其他为参数值。
2.对于Student类，设计无参构造方法，在构造方法中为age赋值为7，name赋值为“无名" 并添加语句System.out.println(“无参构造方法”)；
3.设计方法public void display(),方法中显示该学生的姓名和年龄，显示格式为name：无名，age：8
Main类的main方法中，创建1个学生对象，然后调用display方法显示学生信息，接着通过键盘输入1个学生的姓名和年龄，调用display方法去显示学生信息。
输入格式:
在一行内输入学生的姓名和年龄
输出格式:
对每一组输入，输出学生的姓名和年龄。
输入样例:
在这里给出一组输入。例如：
tom 6
jerry 8
输出样例:
在这里给出相应的输出。例如：
无参构造方法
name:无名,age:7
name:tom,age:7
无参构造方法
name:无名,age:7
name:jerry,age:8

import java.util.Scanner;
class Student{
    private String name;
    private  int age;

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age <= 6 ? 7 : age;
    }
    public Student(){
        age=7;
        name="无名";
        System.out.println("无参构造方法");
    }

    public  void display(){
        System.out.println("name:"+name+",age:"+age);
    }
}

public class Main{
    public static void main(String args[]){
        Student s1=new Student();
        s1.display();
        Scanner sc=new Scanner(System.in);
        String name=sc.next();
        int age=sc.nextInt();
        s1.setName(name);
        s1.setAge(age);
        s1.display();
    }
}

12、设计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.*;
class BankAccount
{
    int balance;
    public BankAccount()
    {
        this.balance= 0;
    }
    public BankAccount(Scanner scanner)
    {
        this.balance= scanner.nextInt();
    }
    public int getBalance()
    {
        return this.balance;
    }
    public void withdraw(int x)
    {
        if(this.balance>=x)
        {
            this.balance -= x;
        }
        else
        {
            ;
        }
    }
    public void deposit(int x)
    {
        this.balance += x;
    }
    public void print()
    {
        System.out.println(balance);
    }
}
public class Main
{

    public static void main(String[] args)
    {
        Scanner scanner= new Scanner(System.in);
        BankAccount bk = new BankAccount(scanner);
        int cycle= scanner.nextInt();
        for(int i=0;i<cycle;i++)
        {
            int choice = scanner.nextInt();
            if(choice==1)
            {
                int x= scanner.nextInt();
                bk.deposit(x);
                bk.print();
            }
            else if(choice==2)
            {
                int x= scanner.nextInt();
                bk.withdraw(x);
                bk.print();
            }
        }
        scanner.close();
    }
}

13、学生类定义

定义一个Student类，含类成员变量：
String name、String gender、int score、boolean award，所有的变量为私有(private)。
1.编写有参构造函数：
对name、gender、score、award赋初值；
2. 重写（覆盖）toString方法：
按照格式：类名 [name=, gender=,score=, award=]输出;
3.对每个成员变量生成setter/getter方法；
4.main方法中创建对象并输出。
输入格式:
输入1行学生的信息：姓名、性别、成绩、获奖情况。
输出格式:
通过对象调用toString方法输出学生的姓名、性别、成绩、获奖情况信息。
输入样例:
Rose female 96 true
输出样例:
Student [name=Rose, gender=female, score=96, award=true]

import java.util.Scanner;

class Student{
    private String name;
    private String gender;
    private int score;
    private boolean award;
    public Student(String name, String gender, int score, boolean award){
        this.name = name;
        this.gender = gender;
        this.score = score;
        this.award = award;
    }
    @Override
    public String toString(){
        return "Student [name=" + name + ", gender=" + gender + ", score=" + score + ", award=" + award + "]";
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getGender(){
        return gender;
    }
    public void setGender(String gender){
        this.gender = gender;
    }
    public int getScore(){
        return score;
    }
    public void setScore(int score){
        this.score = score;
    }
    public boolean isAward(){
        return award;
    }
    public void setAward(boolean award){
        this.award = award;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] students = input.split(" ");
        String name = students[0];
        String gender = students[1];
        int score = Integer.parseInt(students[2]);
        boolean award = Boolean.parseBoolean(students[3]);
        Student student = new Student(name, gender, score, award);
        System.out.println(student);
        scanner.close();
    }
}

14、BankAccount类定义定义银行账户BankAccount类。

私有数据成员：余额balance（整型）。
公有成员方法：
无参构造方法BankAccount()：将账户余额初始化为0；
带参构造方法BankAccount(int m)：将账户余额初始化为指定的参数。
int getbalance() 方法：返回账户余额。
void withdraw(int m) 取款方法：从账户余额中提取m指定的款额，如果余额不足，给出” Insufficient balance.”。
void deposit(int m) 存款方法：将m指定的款项存到账户。
在main方法中构造银行账户，对其进行存取款操作。
其中操作类型类型为d表示存款，w表示取款，每次操作后打印账户余额。

输入格式:
账户余额
存取款操作数
操作类型 金额

输出格式:
操作后的账户余额。

输入样例:
在这里给出一组输入。例如：
1000
5
w 400
d 100
w 500
w 300
w 100

输出样例:
在这里给出相应的输出。例如：
balance: 600
balance: 700
balance: 200
Insufficient balance.balance: 200
balance: 100

import java.util.Scanner;

public class BankAccount {
    // 私有数据成员：余额
    private int balance;

    // 无参构造方法：将账户余额初始化为0
    public BankAccount() {
        this.balance = 0;
    }

    // 带参构造方法：将账户余额初始化为指定的参数
    public BankAccount(int balance) {
        this.balance = balance;
    }

    // 获取账户余额的方法
    public int getBalance() {
        return balance;
    }

    // 取款方法：从账户余额中提取指定金额
    public void withdraw(int amount) {
        if (amount > balance) {
            System.out.println(""Insufficient balance.balance: " + this.balance");
        } else {
            balance -= amount;
            System.out.println("balance: " + balance);
        }
    }

    // 存款方法：将指定金额存入账户
    public void deposit(int amount) {
        balance += amount;
        System.out.println("balance: " + balance);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取初始账户余额
        int initialBalance = scanner.nextInt();
        BankAccount account = new BankAccount(initialBalance);

        // 读取存取款操作数
        int numOperations = scanner.nextInt();

        // 循环处理每个操作
        for (int i = 0; i < numOperations; i++) {
            // 读取操作类型和金额
            char operationType = scanner.next().charAt(0);
            int amount = scanner.nextInt();

            // 根据操作类型执行相应的方法
            if (operationType == 'd') {
                account.deposit(amount);
            } else if (operationType == 'w') {
                account.withdraw(amount);
            } else {
                System.out.println("Invalid operation type.");
            }
        }

        // 关闭Scanner对象
        scanner.close();
    }
}

15、设计一个矩形类Rectangle

编写一个Java应用程序，该程序包含两个类，类的定义如下：
(1) 一个有关计算矩形面积的类Rectangle，定义如下成员：
① 两个私有的成员变量：length（长，double类型）、width（宽，double类型）；
② 一个公有的无参数的构造方法，该构造方法将所有成员变量初始化为零；
③ 一个公有的有参数的方法void setXY(double a, double b)，该方法用于设置矩形的属性length与width；
④ 一个公有的无参数的方法double getArea( )，该方法计算并返回矩形的面积;
⑤一个公有的无参数的方法double getPerimeter( )，该方法计算并返回矩形的周长;
(2) 一个测试类Main，在main方法中声明1个Rectangle类的对象rect，通过setXY方法给rect的属性length和width进行赋值（从键盘输入），通过getArea方法来计算rect的面积，通过getPerimeter方法来计算rect的周长，然后输出其面积与周长。

输入格式:
输入两个数，作为矩形的长、宽。

输出格式:
第一行输出矩形的面积。
第二行输出矩形的周长。

输入样例:
3.5 2

输出样例:
面积为7.0
周长为11.0

import java.util.Scanner;

class Rectangle{
    private double length;
    private double width;
    public Rectangle(){
        this.length = 0;
        this.width = 0;
    }
    public void setXY(double a, double b){
        this.length = a;
        this.width = b;
    }
    public double getArea(){
        return this.length * this.width;
    }
    public double getPerimeter(){
        return 2 * (this.length + this.width);
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Rectangle rect = new Rectangle();
        double length = scanner.nextDouble();
        double width = scanner.nextDouble();
        rect.setXY(length, width);
        System.out.println("面积为" + rect.getArea());
        System.out.println("周长为" + rect.getPerimeter());
    }
}

16、类和对象的使用

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.Scanner;

public class Main{
    public static void main(String args[]){
        String name;
        String sex;
        String studentID;
        int age;
        String major;
        Scanner sc=new Scanner(System.in);
        name=sc.next();
        sex=sc.next();
        age=sc.nextInt();
        major=sc.next();
        studentID=sc.next();
        Student s1=new Student(name, sex, studentID, age, major);
        s1.printInfo();
        s1.toString();
    }
}

class Student{
    private String name;
    private String sex;
    private String studentID;
    private int age;
    private String major;
    public Student(){};
    public Student(String name,String sex,String studentID,int age,String major){
        this.name=name;
        this.sex=sex;
        this.studentID=studentID;
        this.age=age;
        this.major=major;
    }
    public void set(){}
    public String getname(String name){
        return this.name;
    }
    public String getsex(String sex){
        return this.sex;
    }
    public String studentID(String studentID){
        return this.studentID;
    }
    public int age(int age){
        return this.age;
    }
    public String major(String major){
        return this.major;
    }
    public String toString(){
        return "姓名："+this.name+", 性别："+this.sex+", 学号："+this.studentID+", 年龄："+this.age+", 专业："+this.major;}//获取学生所有属性的方法
    public void printInfo(){
        System.out.print("姓名："+this.name);
        System.out.print("，性别："+this.sex);
        System.out.print("，学号："+this.studentID);
        System.out.print(",年龄："+this.age);
        System.out.print(",专业："+this.major);
    }
}

测试点

import java.util.Scanner;

public class Main{
    public static void main(String args[]){
        String name;
        String sex;
        String studentID;
        int age;
        String major;
        Scanner sc=new Scanner(System.in);
        name=sc.next();
        sex=sc.next();
        age=sc.nextInt();
        major=sc.next();
        studentID=sc.next();
        System.out.print("姓名："+ name);
        System.out.print("，性别："+ sex);
        System.out.print("，学号："+ studentID);
        System.out.print(",年龄："+ age);
        System.out.print(",专业："+ major);
    }
}

17、定义接口（Biology、Animal）、类（Person）、子类（Pupil）

（1）定义Biology（生物）、Animal（动物）2个接口，其中Biology声明了抽象方法breathe( )，Animal声明了抽象方法eat( )和sleep( )。
（2）定义一个类Person（人）实现上述2个接口，实现了所有的抽象方法，同时自己还有一个方法think( )。breathe()、eat()、sleep()、think()四个方法分别输出：
我喜欢呼吸新鲜空气
我会按时吃饭
早睡早起身体好
我喜欢思考
（3）定义Person类的子类Pupil（小学生），有私有的成员变量school（学校），公有的成员方法setSchool( )、getSchool( )分别用于设置、获取学校信息。
（4）在测试类Main中，用Pupil类创建一个对象zhangsan。尝试从键盘输入学校信息给zhangsan，获取到该信息后输出该学校信息，格式为“我的学校是XXX”；依次调用zhangsan的breathe()、eat()、sleep()、think()方法。
输入格式:

从键盘输入一个学校名称（字符串格式）

输出格式:

第一行输出：我的学校是XXX（XXX为输入的学校名称）
第二行是breathe()方法的输出
第三行是eat()方法的输出
第四行是sleep()方法的输出
第五行是think()方法的输出

输入样例:

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

新余市逸夫小学
输出样例:

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

我的学校是新余市逸夫小学
我喜欢呼吸新鲜空气
我会按时吃饭
早睡早起身体好
我喜欢思考

import java.util.Scanner;

interface Biology {
    void breathe();
}
interface Animal {
    void eat();
    void sleep();
}
class Person implements Biology, Animal {
    @Override
    public void breathe() {
        System.out.println("我喜欢呼吸新鲜空气");
    }

    @Override
    public void eat() {
        System.out.println("我会按时吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("早睡早起身体好");
    }

    public void think() {
        System.out.println("我喜欢思考");
    }
}
class Pupil extends Person {
    private String school;

    public void setSchool(String school) {
        this.school = school;
    }

    public String getSchool() {
        return school;
    }

    public void inputSchoolInfo() {
        Scanner scanner = new Scanner(System.in);
        setSchool(scanner.nextLine());
        scanner.close();
    }
}

public class Main {
    public static void main(String[] args) {
        Pupil pupil = new Pupil();
        pupil.inputSchoolInfo();
        System.out.println("我的学校是" + pupil.getSchool());
        pupil.breathe();
        pupil.eat();
        pupil.sleep();
        pupil.think();
    }
}

在Java接口中，方法默认就是抽象的（即abstract关键字是可选的，并且通常不写出来）。因此，在Biology和Animal接口中，您不需要显式地声明方法为abstract。

测试点

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        String school;
        Scanner scanner = new Scanner(System.in);
        school = scanner.nextLine();
        System.out.println("我的学校是" + school);
        System.out.println("我喜欢呼吸新鲜空气");
        System.out.println("我会按时吃饭");
        System.out.println("早睡早起身体好");
        System.out.println("我喜欢思考");
    }
}