Java期末复习

1、定义三个重载方法max()，第一个方法，返回两个int值中的最大值，
第二个方法，返回两个double值中的最大值，第三个方法，
返回三个double值中的最大值，并分别调用三个方法

public class MaxValue {
    
    // 返回两个int值中的最大值
    public static int max(int a, int b) {
        return (a > b) ? a : b;
    }
    
    // 返回两个double值中的最大值
    public static double max(double a, double b) {
        return (a > b) ? a : b;
    }
    
    // 返回三个double值中的最大值
    public static double max(double a, double b, double c) {
        return max(max(a, b), c);
    }

    public static void main(String[] args) {
        // 调用第一个max方法
        int intMax = max(3, 7);
        System.out.println("Max of 3 and 7 is: " + intMax);

        // 调用第二个max方法
        double doubleMax = max(4.5, 2.3);
        System.out.println("Max of 4.5 and 2.3 is: " + doubleMax);

        // 调用第三个max方法
        double tripleMax = max(1.2, 3.4, 2.8);
        System.out.println("Max of 1.2, 3.4 and 2.8 is: " + tripleMax);
    }
}

2、编写程序，类Methods中定义三个重载方法并调用。方法名为m。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，
相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法

public class Methods {

    // 接收一个int参数，执行平方运算并输出结果
    public void m(int a) {
        int result = a * a;
        System.out.println("Square of " + a + " is: " + result);
    }

    // 接收两个int参数，相乘并输出结果
    public void m(int a, int b) {
        int result = a * b;
        System.out.println("Product of " + a + " and " + b + " is: " + result);
    }

    // 接收一个字符串参数，输出字符串信息
    public void m(String message) {
        System.out.println("Message: " + message);
    }

    public static void main(String[] args) {
        // 创建 Methods 类的实例
        Methods methods = new Methods();

        // 分别调用三个重载方法
        methods.m(5);         // 调用第一个方法，输出 5 的平方
        methods.m(3, 7);      // 调用第二个方法，输出 3 和 7 的乘积
        methods.m("Hello");   // 调用第三个方法，输出字符串 "Hello"
    }
}

3、用封装实现不能随便查看人的年龄,工资等隐私，并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认年龄, 必须在 1-120, 年龄， 工资不能直接查看 ， name的长度在 2-6字符 之间

public class Person {
    // 私有变量，不能直接访问
    private String name;
    private int age;
    private double salary;

    // 公有方法来访问和修改这些变量

    // 获取姓名
    public String getName() {
        return name;
    }

    // 设置姓名，验证长度在2-6字符之间
    public void setName(String name) {
        if (name != null && name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("Invalid name length. Name should be between 2 and 6 characters.");
            this.name = "Default";
        }
    }

    // 获取年龄
    public int getAge() {
        return age;
    }

    // 设置年龄，验证在1-120之间
    public void setAge(int age) {
        if (age >= 1 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("Invalid age. Age should be between 1 and 120.");
            this.age = 18; // 默认年龄
        }
    }

    // 获取工资
    public double getSalary() {
        return salary;
    }

    // 设置工资
    public void setSalary(double salary) {
        this.salary = salary;
    }

    public static void main(String[] args) {
        Person person = new Person();

        // 设置姓名并获取
        person.setName("John");
        System.out.println("Name: " + person.getName());

        person.setName("J");
        System.out.println("Name: " + person.getName());

        // 设置年龄并获取
        person.setAge(25);
        System.out.println("Age: " + person.getAge());

        person.setAge(150);
        System.out.println("Age: " + person.getAge());

        // 设置工资并获取
        person.setSalary(5000);
        // 因为工资是隐私，所以不直接输出

        System.out.println("Salary: " + person.getSalary());
    }
}

4、封装实现创建程序,在其中定义两个类：Account和AccountTest类体会Java的封装性。

  • Account类要求具有属性：姓名（长度为2位3位或4位）、余额(必须>20)、
  • 密码（必须是六位）, 如果不满足，则给出提示信息，并给默认值(程序员自己定)
  • 通过setXxx的方法给Account 的属性赋值。
  • 在AccountTest中测试

Account 类

public class Account {
    // 私有属性
    private String name;
    private double balance;
    private String password;

    // 获取姓名
    public String getName() {
        return name;
    }

    // 设置姓名，验证长度为2位、3位或4位
    public void setName(String name) {
        if (name != null && (name.length() == 2 || name.length() == 3 || name.length() == 4)) {
            this.name = name;
        } else {
            System.out.println("Invalid name length. Setting default name.");
            this.name = "Default";
        }
    }

    // 获取余额
    public double getBalance() {
        return balance;
    }

    // 设置余额，验证必须大于20
    public void setBalance(double balance) {
        if (balance > 20) {
            this.balance = balance;
        } else {
            System.out.println("Invalid balance. Setting default balance.");
            this.balance = 20.0; // 默认余额
        }
    }

    // 获取密码
    public String getPassword() {
        return password;
    }

    // 设置密码，验证必须是六位
    public void setPassword(String password) {
        if (password != null && password.length() == 6) {
            this.password = password;
        } else {
            System.out.println("Invalid password length. Setting default password.");
            this.password = "123456"; // 默认密码
        }
    }
}

AccountTest 类

public class AccountTest {
    public static void main(String[] args) {
        Account account = new Account();

        // 测试设置姓名
        account.setName("Tom");
        System.out.println("Name: " + account.getName());

        account.setName("Alexander");
        System.out.println("Name: " + account.getName());

        // 测试设置余额
        account.setBalance(50);
        System.out.println("Balance: " + account.getBalance());

        account.setBalance(10);
        System.out.println("Balance: " + account.getBalance());

        // 测试设置密码
        account.setPassword("654321");
        System.out.println("Password: " + account.getPassword());

        account.setPassword("abc");
        System.out.println("Password: " + account.getPassword());
    }
}

5、继承实现编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回Computer的详细信息
编写PC子类，继承Computer类，添加特有属性【品牌brand】
编写NotePad子类，继承Computer类，添加特有属性【color】//同学们自己写。
编写Test类，在main方法中创建PC和NotePad对象，分别给对象中特有的属性赋值，
以及从Computer类继承的属性赋值，并使用方法并打印输出信息

Computer 类

public class Computer {
    private String cpu;
    private int memory;
    private int storage;

    // 构造方法
    public Computer(String cpu, int memory, int storage) {
        this.cpu = cpu;
        this.memory = memory;
        this.storage = storage;
    }

    // 获取详细信息的方法
    public String getDetails() {
        return "CPU: " + cpu + ", Memory: " + memory + "GB, Storage: " + storage + "GB";
    }

    // Getter 和 Setter 方法
    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getStorage() {
        return storage;
    }

    public void setStorage(int storage) {
        this.storage = storage;
    }
}

PC 子类

public class PC extends Computer {
    private String brand;

    // 构造方法
    public PC(String cpu, int memory, int storage, String brand) {
        super(cpu, memory, storage);
        this.brand = brand;
    }

    // 获取详细信息的方法
    @Override
    public String getDetails() {
        return super.getDetails() + ", Brand: " + brand;
    }

    // Getter 和 Setter 方法
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

NotePad 子类

public class NotePad extends Computer {
    private String color;

    // 构造方法
    public NotePad(String cpu, int memory, int storage, String color) {
        super(cpu, memory, storage);
        this.color = color;
    }

    // 获取详细信息的方法
    @Override
    public String getDetails() {
        return super.getDetails() + ", Color: " + color;
    }

    // Getter 和 Setter 方法
    public String getColor() {
        return color;
    }

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

Test 类

public class Test {
    public static void main(String[] args) {
        // 创建PC对象
        PC pc = new PC("Intel i7", 16, 512, "Dell");
        System.out.println("PC Details: " + pc.getDetails());

        // 创建NotePad对象
        NotePad notePad = new NotePad("AMD Ryzen 5", 8, 256, "Silver");
        System.out.println("NotePad Details: " + notePad.getDetails());
    }
}

6、通过super关键字实现当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

父类 Computer

public class Computer {
    private String cpu;
    private int memory;
    private int storage;

    // 无参构造器
    public Computer() {
        System.out.println("Computer's no-arg constructor called");
    }

    // 有参构造器
    public Computer(String cpu, int memory, int storage) {
        this.cpu = cpu;
        this.memory = memory;
        this.storage = storage;
        System.out.println("Computer's parameterized constructor called");
    }

    // 获取详细信息的方法
    public String getDetails() {
        return "CPU: " + cpu + ", Memory: " + memory + "GB, Storage: " + storage + "GB";
    }

    // Getter 和 Setter 方法
    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getStorage() {
        return storage;
    }

    public void setStorage(int storage) {
        this.storage = storage;
    }
}

使用 super 关键字可以显式调用父类的构造器。在子类构造器中，如果没有指定调用父类构造器，Java会默认调用父类的无参构造器。如果父类没有无参构造器，必须在子类构造器中使用 super 关键字指定调用父类的有参构造器。以下是一个示例实现。

父类 Computer
java

public class Computer {
    private String cpu;
    private int memory;
    private int storage;

    // 无参构造器
    public Computer() {
        System.out.println("Computer's no-arg constructor called");
    }

    // 有参构造器
    public Computer(String cpu, int memory, int storage) {
        this.cpu = cpu;
        this.memory = memory;
        this.storage = storage;
        System.out.println("Computer's parameterized constructor called");
    }

    // 获取详细信息的方法
    public String getDetails() {
        return "CPU: " + cpu + ", Memory: " + memory + "GB, Storage: " + storage + "GB";
    }

    // Getter 和 Setter 方法
    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getStorage() {
        return storage;
    }

    public void setStorage(int storage) {
        this.storage = storage;
    }
}

使用 super 关键字可以显式调用父类的构造器。在子类构造器中，如果没有指定调用父类构造器，Java会默认调用父类的无参构造器。如果父类没有无参构造器，必须在子类构造器中使用 super 关键字指定调用父类的有参构造器。以下是一个示例实现。

父类 Computer
java

public class Computer {
    private String cpu;
    private int memory;
    private int storage;

    // 无参构造器
    public Computer() {
        System.out.println("Computer's no-arg constructor called");
    }

    // 有参构造器
    public Computer(String cpu, int memory, int storage) {
        this.cpu = cpu;
        this.memory = memory;
        this.storage = storage;
        System.out.println("Computer's parameterized constructor called");
    }

    // 获取详细信息的方法
    public String getDetails() {
        return "CPU: " + cpu + ", Memory: " + memory + "GB, Storage: " + storage + "GB";
    }

    // Getter 和 Setter 方法
    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getStorage() {
        return storage;
    }

    public void setStorage(int storage) {
        this.storage = storage;
    }
}

使用 super 关键字可以显式调用父类的构造器。在子类构造器中，如果没有指定调用父类构造器，Java会默认调用父类的无参构造器。如果父类没有无参构造器，必须在子类构造器中使用 super 关键字指定调用父类的有参构造器。以下是一个示例实现。

父类 Computer
java

public class Computer {
    private String cpu;
    private int memory;
    private int storage;

    // 无参构造器
    public Computer() {
        System.out.println("Computer's no-arg constructor called");
    }

    // 有参构造器
    public Computer(String cpu, int memory, int storage) {
        this.cpu = cpu;
        this.memory = memory;
        this.storage = storage;
        System.out.println("Computer's parameterized constructor called");
    }

    // 获取详细信息的方法
    public String getDetails() {
        return "CPU: " + cpu + ", Memory: " + memory + "GB, Storage: " + storage + "GB";
    }

    // Getter 和 Setter 方法
    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getStorage() {
        return storage;
    }

    public void setStorage(int storage) {
        this.storage = storage;
    }
}

子类PC

public class PC extends Computer {
    private String brand;

    // 无参构造器
    public PC() {
        super(); // 调用父类的无参构造器
        System.out.println("PC's no-arg constructor called");
    }

    // 有参构造器
    public PC(String cpu, int memory, int storage, String brand) {
        super(cpu, memory, storage); // 调用父类的有参构造器
        this.brand = brand;
        System.out.println("PC's parameterized constructor called");
    }

    // 获取详细信息的方法
    @Override
    public String getDetails() {
        return super.getDetails() + ", Brand: " + brand;
    }

    // Getter 和 Setter 方法
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

子类 NotePad

public class NotePad extends Computer {
    private String color;

    // 无参构造器
    public NotePad() {
        super(); // 调用父类的无参构造器
        System.out.println("NotePad's no-arg constructor called");
    }

    // 有参构造器
    public NotePad(String cpu, int memory, int storage, String color) {
        super(cpu, memory, storage); // 调用父类的有参构造器
        this.color = color;
        System.out.println("NotePad's parameterized constructor called");
    }

    // 获取详细信息的方法
    @Override
    public String getDetails() {
        return super.getDetails() + ", Color: " + color;
    }

    // Getter 和 Setter 方法
    public String getColor() {
        return color;
    }

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

Test 类

public class Test {
    public static void main(String[] args) {
        // 创建PC对象，使用无参构造器
        PC pc1 = new PC();
        pc1.setCpu("Intel i7");
        pc1.setMemory(16);
        pc1.setStorage(512);
        pc1.setBrand("Dell");
        System.out.println("PC1 Details: " + pc1.getDetails());

        // 创建PC对象，使用有参构造器
        PC pc2 = new PC("Intel i5", 8, 256, "HP");
        System.out.println("PC2 Details: " + pc2.getDetails());

        // 创建NotePad对象，使用无参构造器
        NotePad notePad1 = new NotePad();
        notePad1.setCpu("AMD Ryzen 5");
        notePad1.setMemory(8);
        notePad1.setStorage(256);
        notePad1.setColor("Silver");
        System.out.println("NotePad1 Details: " + notePad1.getDetails());

        // 创建NotePad对象，使用有参构造器
        NotePad notePad2 = new NotePad("AMD Ryzen 7", 16, 512, "Black");
        System.out.println("NotePad2 Details: " + notePad2.getDetails());
    }
}

7、通过重写实现编写一个 Person 类，包括属性/private（name、age），构造器、方法 say(返回自我介绍的字符串）。
编写一个 Student 类，继承 Person 类，增加 id、score 属性/private，以及构造器，定义 say 方法(返回自我介绍的信息)。
在 main 中,分别创建 Person 和 Student 对象，调用 say 方法输出自我介绍

Person 类

public class Person {
    // 私有属性
    private String name;
    private int age;

    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    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;
    }

    // say 方法，返回自我介绍的字符串
    public String say() {
        return "Hello, my name is " + name + " and I am " + age + " years old.";
    }
}

Student 类

public class Student extends Person {
    // 私有属性
    private int id;
    private double score;

    // 构造器
    public Student(String name, int age, int id, double score) {
        super(name, age); // 调用父类的构造器
        this.id = id;
        this.score = score;
    }

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    // 重写 say 方法，返回自我介绍的字符串
    @Override
    public String say() {
        return "Hello, my n
ame is " + getName() + ", I am " + getAge() + " years old, " +
               "my student ID is " + id + " and my score is " + score + ".";
    }
}

Test 类

public class Test {
    public static void main(String[] args) {
        // 创建 Person 对象
        Person person = new Person("John", 30);
        System.out.println(person.say());

        // 创建 Student 对象
        Student student = new Student("Alice", 20, 12345, 95.5);
        System.out.println(student.say());
    }
}

8、通过重写实现编写一个 Person 类，包括属性/private（name、age），构造器、方法 say(返回自我介绍的字符串）。
编写一个 Student 类，继承 Person 类，增加 id、score 属性/private，以及构造器，定义 say 方法(返回自我介绍的信息)。
在父类和子类中分别定义一个doing方法父类输出XXX正在做……，子类输出XXX正在上课
在 main 中,分别创建 Person 和 Student 对象，调用 say 方法输出自我介绍

Person 类

public class Person {
    // 私有属性
    private String name;
    private int age;

    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    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;
    }

    // say 方法，返回自我介绍的字符串
    public String say() {
        return "Hello, my name is " + name + " and I am " + age + " years old.";
    }

    // doing 方法，返回正在做的事情
    public void doing() {
        System.out.println(name + " is doing something...");
    }
}

Student 类

public class Student extends Person {
    // 私有属性
    private int id;
    private double score;

    // 构造器
    public Student(String name, int age, int id, double score) {
        super(name, age); // 调用父类的构造器
        this.id = id;
        this.score = score;
    }

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    // 重写 say 方法，返回自我介绍的字符串
    @Override
    public String say() {
        return "Hello, my name is " + getName() + ", I am " + getAge() + " years old, " +
               "my student ID is " + id + " and my score is " + score + ".";
    }

    // 重写 doing 方法，返回正在上课的信息
    @Override
    public void doing() {
        System.out.println(getName() + " is attending class...");
    }
}

Test 类

public class Test {
    public static void main(String[] args) {
        // 创建 Person 对象
        Person person = new Person("John", 30);
        System.out.println(person.say());
        person.doing();

        // 创建 Student 对象
        Student student = new Student("Alice", 20, 12345, 95.5);
        System.out.println(student.say());
        student.doing();
    }
}

9、写程序演示类被加载的情况举例
1. 创建对象实例时(new)
AA3 aa = new AA3();
2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
AA3 aa2 = new AA3();
3. 使用类的静态成员时(静态属性，静态方法)
System.out.println(Cat.n1);
static代码块，是在类加载时，执行的，而且只会执行一次.
DD3 dd = new DD3();
DD3 dd1 = new DD3();
普通的代码块，在创建对象实例时，会被隐式的调用。
被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行

AA3 类

class AA3 {
    // 静态属性
    static int n1 = initializeStaticVariable();

    // 静态代码块
    static {
        System.out.println("AA3's static block executed");
    }

    // 普通代码块
    {
        System.out.println("AA3's instance block executed");
    }

    // 构造器
    public AA3() {
        System.out.println("AA3's constructor executed");
    }

    // 静态方法
    public static int initializeStaticVariable() {
        System.out.println("AA3's static variable initialized");
        return 100;
    }
}

BB3 类（继承 AA3）

class BB3 extends AA3 {
    // 静态代码块
    static {
        System.out.println("BB3's static block executed");
    }

    // 普通代码块
    {
        System.out.println("BB3's instance block executed");
    }

    // 构造器
    public BB3() {
        System.out.println("BB3's constructor executed");
    }
}

CC3 类

class CC3 {
    // 静态属性
    static int n1 = initializeStaticVariable();

    // 静态代码块
    static {
        System.out.println("CC3's static block executed");
    }

    // 普通代码块
    {
        System.out.println("CC3's instance block executed");
    }

    // 构造器
    public CC3() {
        System.out.println("CC3's constructor executed");
    }

    // 静态方法
    public static int initializeStaticVariable() {
        System.out.println("CC3's static variable initialized");
        return 200;
    }
}

DD3 类

class DD3 {
    // 静态属性
    static int n1 = initializeStaticVariable();

    // 静态代码块
    static {
        System.out.println("DD3's static block executed");
    }

    // 普通代码块
    {
        System.out.println("DD3's instance block executed");
    }

    // 构造器
    public DD3() {
        System.out.println("DD3's constructor executed");
    }

    // 静态方法
    public static int initializeStaticVariable() {
        System.out.println("DD3's static variable initialized");
        return 300;
    }
}

Test 类

public class Test {
    public static void main(String[] args) {
        // 1. 创建对象实例时(new)
        System.out.println("Creating AA3 object:");
        AA3 aa = new AA3();

        // 2. 创建子类对象实例时，父类也会被加载，父类先被加载，子类后被加载
        System.out.println("\nCreating BB3 object:");
        BB3 bb = new BB3();

        // 3. 使用类的静态成员时(静态属性，静态方法)
        System.out.println("\nAccessing CC3's static member:");
        System.out.println("CC3's static variable n1: " + CC3.n1);

        // 4. 静态代码块在类加载时执行，并且只会执行一次
        System.out.println("\nCreating DD3 object:");
        DD3 dd = new DD3();
        System.out.println("Creating another DD3 object:");
        DD3 dd1 = new DD3();
    }
}

10、写程序演示类成员的调用顺序，(1) A 静态代码块01 (2) getN1被调用...(3)A 普通代码块01(4)getN2被调用...(5)A() 构造器被调用

public class A {
    // 静态属性
    static int n1 = initializeStaticVariable();

    // 静态代码块01
    static {
        System.out.println("A's static block 01 executed");
    }

    // 普通属性
    int n2 = initializeInstanceVariable();

    // 普通代码块01
    {
        System.out.println("A's instance block 01 executed");
    }

    // 构造器
    public A() {
        System.out.println("A's constructor executed");
    }

    // 静态方法
    public static int initializeStaticVariable() {
        System.out.println("getN1 method called");
        return 100;
    }

    // 普通方法
    public int initializeInstanceVariable() {
        System.out.println("getN2 method called");
        return 200;
    }

    public static void main(String[] args) {
        System.out.println("Creating A object:");
        A a = new A();
    }
}

11、编写程序演示构造器隐含(1)super()(2)调用本类的普通代码块

class Parent {
    // 父类的普通代码块
    {
        System.out.println("Parent's instance block executed");
    }

    // 父类的构造器
    public Parent() {
        System.out.println("Parent's constructor executed");
    }
}

public class Child extends Parent {
    // 子类的普通代码块
    {
        System.out.println("Child's instance block executed");
    }

    // 子类的构造器
    public Child() {
        System.out.println("Child's constructor executed");
    }

    public static void main(String[] args) {
        System.out.println("Creating Child object:");
        Child child = new Child();
    }
}

13、通过多态实现一个动物叫的方法，由于每种动物的叫声是不同的，因此可以在方法中接收一个动物类型的参数，当传入猫类对象时就发出猫类的叫声，传入犬类对象时就发出犬类的叫声。

// 动物类
class Animal {
    // 叫的方法
    public void makeSound() {
        System.out.println("动物发出叫声");
    }
}

// 猫类
class Cat extends Animal {
    // 重写父类的makeSound方法
    @Override
    public void makeSound() {
        System.out.println("猫发出喵喵的叫声");
    }
}

// 犬类
class Dog extends Animal {
    // 重写父类的makeSound方法
    @Override
    public void makeSound() {
        System.out.println("狗发出汪汪的叫声");
    }
}

// 测试类
public class Test {
    // 叫的方法，接收一个动物类型的参数
    public static void animalSound(Animal animal) {
        animal.makeSound(); // 多态调用
    }

    public static void main(String[] args) {
        // 创建猫和狗对象
        Animal cat = new Cat();
        Animal dog = new Dog();

        // 调用叫的方法，传入不同的动物对象
        System.out.println("传入猫对象：");
        animalSound(cat);

        System.out.println("\n传入狗对象：");
        animalSound(dog);
    }
}

// 动物类
class Animal {
    public void eat() {
        System.out.println("动物正在吃东西");
    }
}

// 猫类
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫正在吃鱼");
    }

    public void meow() {
        System.out.println("喵喵喵~");
    }
}

// 狗类
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗正在啃骨头");
    }

    public void bark() {
        System.out.println("汪汪汪~");
    }
}

public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal animal1 = new Cat(); // 猫向上转型为动物
        Animal animal2 = new Dog(); // 狗向上转型为动物

        // 调用动物类的方法
        animal1.eat(); // 输出：猫正在吃鱼
        animal2.eat(); // 输出：狗正在啃骨头

        // 向下转型
        if (animal1 instanceof Cat) {
            Cat cat = (Cat) animal1; // 向下转型为猫
            cat.meow(); // 输出：喵喵喵~
        }

        if (animal2 instanceof Dog) {
            Dog dog = (Dog) animal2; // 向下转型为狗
            dog.bark(); // 输出：汪汪汪~
        }
    }
}

16、1）定义一个抽象类Weapon,该抽象类有两个抽象方法attack()，move()
这两个方法分别表示武器的攻击方式和移动方式。
（2）定义3个类：Tank,Flighter,WarShip都继承自Weapon,
分别用不同的方式实现Weapon类中的抽象方法。

// 抽象类 Weapon
abstract class Weapon {
    // 抽象方法 attack，表示武器的攻击方式
    public abstract void attack();

    // 抽象方法 move，表示武器的移动方式
    public abstract void move();
}

// 坦克类，继承自 Weapon
class Tank extends Weapon {
    @Override
    public void attack() {
        System.out.println("坦克发射炮弹");
    }

    @Override
    public void move() {
        System.out.println("坦克通过履带移动");
    }
}

// 战斗机类，继承自 Weapon
class Flighter extends Weapon {
    @Override
    public void attack() {
        System.out.println("战斗机发射导弹");
    }

    @Override
    public void move() {
        System.out.println("战斗机通过喷射推进器飞行");
    }
}

// 军舰类，继承自 Weapon
class WarShip extends Weapon {
    @Override
    public void attack() {
        System.out.println("军舰发射鱼雷");
    }

    @Override
    public void move() {
        System.out.println("军舰通过螺旋桨航行");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 创建坦克对象
        Weapon tank = new Tank();
        System.out.println("坦克的攻击方式和移动方式：");
        tank.attack(); // 坦克发射炮弹
        tank.move();   // 坦克通过履带移动

        // 创建战斗机对象
        Weapon flighter = new Flighter();
        System.out.println("\n战斗机的攻击方式和移动方式：");
        flighter.attack(); // 战斗机发射导弹
        flighter.move();   // 战斗机通过喷射推进器飞行

        // 创建军舰对象
        Weapon warShip = new WarShip();
        System.out.println("\n军舰的攻击方式和移动方式：");
        warShip.attack(); // 军舰发射鱼雷
        warShip.move();   // 军舰通过螺旋桨航行
    }
}

21、要求输入对象的年龄在18-120之间，否则抛出一个自定义异常

// 自定义异常类 AgeOutOfRangeException
class AgeOutOfRangeException extends Exception {
    public AgeOutOfRangeException(String message) {
        super(message);
    }
}

// 测试类
public class Test {
    // 方法用于验证年龄是否在合法范围内
    public static void validateAge(int age) throws AgeOutOfRangeException {
        if (age < 18 || age > 120) {
            throw new AgeOutOfRangeException("年龄必须在18到120之间");
        }
    }

    public static void main(String[] args) {
        int age = 15; // 假设输入的年龄是15岁

        try {
            // 验证年龄是否在合法范围内
            validateAge(age);
            System.out.println("输入的年龄合法：" + age);
        } catch (AgeOutOfRangeException e) {
            System.out.println("输入的年龄不合法：" + e.getMessage());
        }
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 214,100评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,308评论 3赞 388
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 159,718评论 0赞 349
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,275评论 1赞 287
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,376评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,454评论 1赞 292
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,464评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,248评论 0赞 269
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,686评论 1赞 306
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,974评论 2赞 328
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,150评论 1赞 342
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,817评论 4赞 337
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,484评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,140评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,374评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,012评论 2赞 365
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,041评论 2赞 351

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,605评论 18赞 399
  • 类和对象
    1、类 创建类 public class Computer { //修饰符public：类可以被任意访问 //类的...
    小短腿要早睡啊阅读 447评论 0赞 0
  • 设计模式
    原创者：文思 一、设计原则 设计模式的目的：代码重用性、可读性、维护性...
    文思li阅读 374评论 0赞 0
  • Java语言基础学习关键字：abstract和interface
    一、抽象类与抽象方法 1.抽象类定义： 随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用...
    不差不多阅读 242评论 0赞 0
  • Java面试
    一. Java基础部分.................................................
    wy_sure阅读 3,808评论 0赞 11