// 创建Phone类的对象p1
Phone p1 = new Phone();
p1.name = "huawei";   // 设置属性
p1.price = 6999;      // 设置属性

// 输出属性
System.out.println("name=" + p1.name);  // 输出 name 属性

// 用户类
public class User {
    private String username;  // 用户名
    private String password;  // 密码

    // 构造器，初始化用户名和密码
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    // Getter 和 Setter 方法
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    // 通用用户登录方法
    public void login() {
        System.out.println(username + " is logging in.");
    }
}

// 管理员类，继承User类
public class Admin extends User {
    public Admin(String username, String password) {
        super(username, password);
    }

    // 管理员特有方法
    public void manageUsers() {
        System.out.println(getUsername() + " is managing users.");
    }
}

// 超级管理员类，继承Admin类
public class SuperAdmin extends Admin {
    public SuperAdmin(String username, String password) {
        super(username, password);
    }

    // 超级管理员特有方法
    public void grantAdminRights() {
        System.out.println(getUsername() + " is granting admin rights.");
    }
}

// 用户管理类，用于测试创建用户、管理员和超级管理员
public class UserManager {
    public static void main(String[] args) {
        // 创建普通用户
        User regularUser = new User("johnDoe", "password123");
        regularUser.login();

        // 创建管理员
        Admin adminUser = new Admin("janeAdmin", "adminpass");
        adminUser.login();
        adminUser.manageUsers();

        // 创建超级管理员
        SuperAdmin superAdminUser = new SuperAdmin("bobSuper", "superpass");
        superAdminUser.login();
        superAdminUser.manageUsers();
        superAdminUser.grantAdminRights();
    }
}

[访问修饰符] [static] 返回类型 方法名(参数类型 参数名, 参数类型 参数名, ...) {
    // 方法体
    // ...
    // 返回语句（如果方法有返回值）
    return 返回值;
}

public class Calculator {

    // 无参数、无返回值的方法
    public void displayMessage() {
        System.out.println("Hello, World!");
    }

    // 有参数、有返回值的方法
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum; // 返回计算结果
    }

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

        // 调用无参数、无返回值的方法
        calc.displayMessage();

        // 调用有参数、有返回值的方法，并打印结果
        int result = calc.add(5, 10);
        System.out.println("The sum is: " + result);
    }
}

权限修饰符 [其它修饰符（非必要）] 返回值类型 方法名（形参列表）{
    // 方法体
}

public void sleep(int hour) {
    System.out.println("人每天最少睡：" + hour + " 小时");
}

public class Factorial {
    // 递归计算阶乘的方法
    public static int factorial(int n) {
        // 递归终止条件：当 n 为 0 时返回 1
        if (n == 0) {
            return 1;
        }
        // 递归调用：计算 n * (n-1)!
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int number = 5;
        int result = factorial(number);
        System.out.println(number + "! = " + result);  // 输出结果
    }
}

// 文件名: RecursionTest.java
public class RecursionTest {
    public static void main(String[] args) {
        // 创建当前类的对象，用于调用实例方法
        RecursionTest rt = new RecursionTest();

        // 调用求和方法（非递归）
        rt.method2();

        // 调用递归求和方法
        System.out.println("1到100的总和：" + rt.method3(100));

        // 调用递归计算阶乘方法
        System.out.println("5的阶乘：" + rt.method4(5));

        // 调用斐波那契数列计算方法
        System.out.println("斐波那契数列第10项：" + rt.method5(10));
    }

    // 递归方法示例：无限递归
    public void method1() {
        System.out.println("method1。。。");
        // 自己调用自己，会导致无限递归
        method1();
    }

    // 非递归求和方法：计算1到100之间的总和
    public void method2() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1到100的总和：" + sum);
    }

    // 递归求和方法：计算1到num的总和
    public int method3(int num) {
        if (num == 1) {
            return 1;
        } else {
            return num + method3(num - 1);
        }
    }

    // 递归计算阶乘：计算n的阶乘 n!
    public int method4(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * method4(n - 1);
        }
    }

    // 递归计算斐波那契数列：f(n) = f(n-1) + f(n-2)
    public int method5(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return method5(n - 1) + method5(n - 2);
        }
    }
}

// 文件名: RecursionExer.java
public class RecursionExer {
    public static void main(String[] args) {
        RecursionExer exer = new RecursionExer();

        // 测试自定义递归方法 f 和 func
        System.out.println("f(20)的值：" + exer.f(20));
        System.out.println("func(20)的值：" + exer.func(20));
    }

    // 递归方法：根据自定义规则定义的递归公式
    public int f(int n) {
        if (n == 20) {
            return 1;
        } else if (n == 21) {
            return 4;
        } else {
            return f(n + 1) + f(n + 2);
        }
    }

    // 递归方法：另一个自定义的递归公式
    public int func(int n) {
        if (n == 0) {
            return 1;
        } else if (n == 1) {
            return 4;
        } else {
            return 2 * func(n - 1) + 2 * func(n - 2);
        }
    }
}

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

public class Test {
    public static void main(String[] args) {
        double area = sqrt(4) * PI; // 使用导入的静态成员
    }
}

import static java.lang.Math.{PI, sqrt};

public class Test {
    public static void main(String[] args) {
        double area = sqrt(4) * PI; // 使用导入的静态成员
    }
}

import static java.lang.Math.*;

public class Test {
    public static void main(String[] args) {
        double area = sqrt(4) * PI; // 使用导入的静态成员
    }
}

package com.example.myapp;

import com.example.myapp.MyClass;

import com.example.myapp.*;

import java.util.List;
import java.util.Map;

import java.util.*;

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

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

    // 公共的getter方法
    public String getName() {
        return name;
    }

    // 公共的setter方法
    public void setName(String name) {
        this.name = name;
    }

    // 公共的getter方法
    public int getAge() {
        return age;
    }

    // 公共的setter方法
    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("Age cannot be negative");
        }
    }
}

public class TestPerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        person.setAge(25);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

/**
 * Test
 */
public class Test {

    public static void main(String[] args) {
        // 创建Animal对象并设置属性
        Animal animl1 = new Animal();
        animl1.name = "金蟾";
        animl1.setLeg(4); // 调用setLeg方法设置腿的数量

        // 打印动物的名字和腿的数量
        System.out.println("动物名称:" + animl1.name + " 动物腿数:" + animl1.getLeg());

        // 访问修饰符
        // public: 公共的，任何类都可以访问
        // private: 私有的，只有本类可以访问
        // protected: 受保护的，本类、同包类、子类可以访问
        // 默认（不写）：本类、同包类可以访问

        // 其他修饰符
        // static: 静态的，类变量、类方法
        // final: 最终的，常量、类、方法、变量
        // abstract: 抽象的，抽象类、抽象方法
        // transient: 瞬态的，不会被序列化的变量
        // volatile: 易变的，多线程操作共享变量
        // synchronized: 同步的，多线程操作共享变量
        // native: 本地的，调用本地方法
        // strictfp: 精确浮点，浮点运算更加精确
        // default: 默认的，接口方法
    }
}

class Animal {
    String name; // 名字
    int age;     // 年龄
    String color;// 颜色
    private int leg; // 腿的数量

    // 设置腿的数量
    public void setLeg(int l) {
        if (l >= 0 && l % 2 == 0) {
            leg = l;
        } else {
            System.out.println("请输入正确的腿数");
        }
    }

    // 获取腿的数量
    public int getLeg() {
        return leg;
    }

    // 动物觅食的方法
    public void eat() {
        System.out.println("动物觅食");
    }
}

public class PersonTest {
    public static void main(String[] args) {
        //创建Person实例1
        Person person1 = new Person();
        // person1.age;
        person1.setAge(18);
    }
}

public class Person {
    private int age;

    //设置age的属性

    public void setAge(int age){
        if(age>= 0 && age <= 150){
            this.age = age;
        }else{
            System.out.println("年龄不合法");
        }
    }

    //获取age的属性

    public int getAge(){
        return age;
    }
}

public class Person {
    private String name;
    private int age;

    // 无参构造器
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        System.out.println("Person created with default values.");
    }

    // 有参构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person created with name: " + name + " and age: " + age);
    }

    // Getter and 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;
    }
}

public class TestConstructor {
    public static void main(String[] args) {
        Person person1 = new Person(); // 调用无参构造器
        Person person2 = new Person("Alice", 30); // 调用有参构造器
    }
}

public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student("张三", 20, "男", "计算机");
        System.out.println(s.name + " " + s.age + " " + s.school + " " + s.major);

        Student s2 = new Student("李四", 21);
        System.out.println(s2.name + " " + s2.age );

        

    }
}

public class Student {
    //构造器说明
    //1.构造器没有返回值
    //2.构造器的名称必须和类名相同
    //3.构造器的作用是完成对对象的初始化操作
    //4.如果你没有显式的定义类的构造器的话，则系统默认提供一个无参数的构造器
    //5.一旦你显式的定义了一个构造器，则系统就不再提供默认的无参数的构造器了
    //6.构造器也是可以重载的


     String name;
     int age;
     String school;
     String major;//主修课

    public Student(String n, int a) {
        name = n;
        age = a;
    }

    public Student(String n, int a, String s) {
        name = n;
        age = a;
        school = s;
    }

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

    
}

public class CustomerTest {
    public static void main(String[] args) {
        //创建Customer实例
        Customer customer = new Customer("Jane", "Smith");

        Account account = new Account(1001, 20000.0, 0.045);
        customer.setAccount(account);

        System.out.println("客户姓名：" + customer.getFirstName() + " " + customer.getLastName());

        //对客户的取钱存钱
        customer.getAccount().deposit(1000);
        customer.getAccount().deposit(2000);
        customer.getAccount().withdraw(5000);

        //输出客户信息
        System.out.println("客户姓名：" + customer.getFirstName() + " " + customer.getLastName());

    }
}

public class Customer {
    private String firstName;
    private String lastName;
    private Account account;

    public Customer(String f,String l){
        firstName=f;
        lastName=l;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

}

public class Account {
    private int id;
    private double balname;//余额
    private double annualInterestRate;//年利率

    public Account(int i,double b,double a){
        id=i;
        balname=b;
        annualInterestRate=a;
    }

    public int getId(){
        return id;

    }

    public void setBalname(double b){
        balname=b;
    }

    public void setId(int i){
        id=i;
    }

    public void setAnnualInterestRate(double a){
        annualInterestRate=a;
    }

    public double getAnnualInterestRate(){
        return annualInterestRate;
    }

    public void withdraw(double m){
        if(m>balname){
            System.out.println("余额不足");
        }else{
            balname=balname-m;
            System.out.println("取款成功");
        }
    }

    public void deposit(double m){
        balname+=m;
        System.out.println("存款成功");
    }

    



}

// 使用匿名对象实现Runnable接口来创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
});

thread.start();

// 使用匿名对象作为方法参数
button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        System.out.println("Button is clicked.");
    }
});

public class Example {
    public int value = 10; // 声明时直接赋值
}

public class Example {
    private int value;
    public Example(int value) {
        this.value = value; // 通过构造器赋值
    }
}

public class Example {
    private int value;
    {
        value = 20; // 实例初始化块赋值
    }
}

public class Example {
    private static int value;
    static {
        value = 30; // 静态初始化块赋值
    }
}

public class Example {
    private int value;
    public void setValue(int value) {
        this.value = value; // 通过setter方法赋值
    }
}

import java.io.Serializable;

public class UserBean implements Serializable {
    private String name;
    private int age;

    // 默认构造器
    public UserBean() {
    }

    // 带参数的构造器
    public UserBean(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;
    }
}

class Phone {
    // 属性
    String brand;
    int memory;

    // 方法
    void call() {
        System.out.println("Making a call...");
    }

    void sendSMS(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

Phone phoneP1 = new Phone();

phoneP1.brand = "Moonshot";
phoneP1.memory = 128;
phoneP1.call();
phoneP1.sendSMS("Hello, World!");

public class Calculator {

    // 计算两个整数的和
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    // 计算两个浮点数的差，可能抛出算术异常
    public double subtract(double num1, double num2) throws ArithmeticException {
        return num1 - num2;
    }

    // 显示欢迎信息，不返回任何值
    public void displayWelcomeMessage() {
        System.out.println("Welcome to the Calculator Application!");
    }
}

public class Example {

    // 方法重载示例：根据参数数量不同
    public void display() {
        System.out.println("Display with no arguments");
    }

    public void display(int number) {
        System.out.println("Display with one argument: " + number);
    }

    public void display(String str) {
        System.out.println("Display with one argument: " + str);
    }

    // 方法重载示例：根据参数类型不同
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

Car[] carArray;

carArray = new Car[3]; // 创建一个可以存储3个Car对象的数组

carArray[0] = new Car();
carArray[1] = new Car();
carArray[2] = new Car();

Car[] carArray = {
    new Car(),
    new Car(),
    new Car()
};

carArray[0].startEngine(); // 调用第一个Car对象的startEngine方法
carArray[1].stopEngine();  // 调用第二个Car对象的stopEngine方法

public class Person {
    private String name;

    public Person(String name) {
        this.name = name; // this.name指的是实例变量，name指的是参数
    }
}

public class Calculator {
    public void add(int a, int b) {
        System.out.println(this.sum(a, b)); // 调用当前对象的sum方法
    }

    private int sum(int a, int b) {
        return a + b;
    }
}

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

    public Rectangle() {
        this(10, 20); // 调用带参数的构造函数
    }

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

public class Builder {
    private String value;

    public Builder setValue(String value) {
        this.value = value;
        return this; // 返回当前对象
    }
}

public class User {
    private String name;
    private int age;

    // 无参数的构造函数
    public User() {
        // 模拟对象创建时，需要初始化50行代码。
        // 这里只是示例，所以没有写出50行代码
    }

    // 带一个参数name的构造函数
    public User(String name) {
        this(); // 调用无参数的构造函数
        this.name = name; // 设置name属性
    }

    // 带两个参数name和age的构造函数
    public User(String name, int age) {
        this(name); // 调用带一个参数的构造函数
        this.age = age; // 设置age属性
    }
}

public class ExtendsTest {
    public static void main(String[] args) {
        Person p1 = new Person();
       
        p1.eat();
        student s1 = new student();
        s1.eat();
    }
}

public class Person extends student{
    //java继承性

    String name;
    int age;

    // public void eat(){
    //     System.out.println("吃饭");
    // }

    // public void sleep(){
    //     System.out.println("睡觉");
    // }

    public void study(){
        System.out.println("学习");
    }


}

public class student {
    
    String name;
    int age;

    //方法
    public void eat(){
        System.out.println("人吃饭");
    }

    public void sleep(){
        System.out.println("人睡觉");
    }

    public void study(){
        System.out.println("人学习");
    }

}

class A{}
class B extends A{}
class C extends B{}

class A{}
class B extends A{}
class D extends A{}
class E extends A{}

public class A{}
class B extends A{}

//一个类只能有一个父类，不可以有多个直接父类。
class C extends B{} 	//ok
class C extends A,B...	//error

public class KindTest {
    public static void main(String[] args) {
        kinds kid = new kinds();

        kid.setSalary(100);
        kid.setSex(1);
        kid.setYearOld(12);

        kid.printAge();
    }
}

public class Mankind{
    private int sex;
    private int salary;

    public Mankind() {

    }   


    public Mankind(int sex,int salary){
        this.sex=sex;
        this.salary=salary;

    }

    public int getSex(){
        return sex;
    }

    public void setSex(int sex){
        this.sex=sex;
    }

    public int getSalary(){
        return salary;
    }

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

    public void manWoman(){
        if(sex==1){
            System.out.println("Man");
        }else{
            System.out.println("Woman");
        }
    }

    public void employeed() {
        if(salary==0){
            System.out.println("no job");
        }else{
            System.out.println("job");
        }
    }


}

public class kinds extends Mankind {
    private int yearOld;

    public kinds(){

    }

    public kinds(int yearOld){
        this.yearOld = yearOld;
    }

    public void setYearOld(int yearOld) {
        this.yearOld = yearOld;
    }

    public void setYearOld(int sex,int salary, int yearOld) {
        setSalary(salary);
        setSex(sex);
    }

    public int getYearOld() {
        return yearOld;
    }

    public void printAge(){
        System.out.println("I am " + yearOld + " years old.");
    }
    
}

public class CylinderTest {
    public static void main(String[] args) {
        Cylinder c = new Cylinder();
        c.setRadius(2);
        c.setLength(3.4);

        System.out.println("半径为" + c.getRadius() + "，高为" + c.getLength() + "的圆柱体体积为：" + c.getVolume(c.getRadius()));
    }
}

public class Cylinder extends circle{
    private double length;

    public Cylinder() {
        length = 1;
    }

    public Cylinder(double length) {
        this.length = length;
    }

    public double getLength() {
        return length;
    }

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

    //求体积
    public double getVolume(double radius) {
        return Math.PI * getRadius() * getRadius() * getLength();
    }

}

public class circle {
    private int radius; 

    public circle() {
        this.radius = 1;
    }

    public circle(int radius) {
        this.radius = radius;
    }

    public int getRadius() {
        return radius;
    }

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

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

    
}

package com.atguigu.inherited.method;

public class TestOverload {
    public int max(int a, int b){
        return a > b ? a : b;
    }
    public double max(double a, double b){
        return a > b ? a : b;
    }
    public int max(int a, int b,int c){
        return max(max(a,b),c);
    }
}

package com.atguigu.inherited.method;

public class TestOverloadOverride {
    public static void main(String[] args) {
        Son s = new Son();
        s.method(1);//只有一个形式的method方法

        Daughter d = new Daughter();
        d.method(1);
        d.method(1,2);//有两个形式的method方法
    }
}

class Father{
    public void method(int i){
        System.out.println("Father.method");
    }
}
class Son extends Father{
    public void method(int i){//重写
        System.out.println("Son.method");
    }
}
class Daughter extends Father{
    public void method(int i,int j){//重载
        System.out.println("Daughter.method");
    }
}

package com.atguigu.inherited.method;

public class TestOverload {
    public int max(int a, int b){
        return a > b ? a : b;
    }
    public double max(double a, double b){
        return a > b ? a : b;
    }
    public int max(int a, int b,int c){
        return max(max(a,b),c);
    }
}

package com.atguigu.inherited.method;

public class TestOverloadOverride {
    public static void main(String[] args) {
        Son s = new Son();
        s.method(1);//只有一个形式的method方法

        Daughter d = new Daughter();
        d.method(1);
        d.method(1,2);//有两个形式的method方法
    }
}

class Father{
    public void method(int i){
        System.out.println("Father.method");
    }
}
class Son extends Father{
    public void method(int i){//重写
        System.out.println("Son.method");
    }
}
class Daughter extends Father{
    public void method(int i,int j){//重载
        System.out.println("Daughter.method");
    }
}

package com.atguigu.inherited.method;

public class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");
    }
}

//smartphone：智能手机
public class SmartPhone extends Phone{
    //重写父类的来电显示功能的方法
    public void showNum(){
        //来电显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");

        //保留父类来电显示号码的功能
        super.showNum();//此处必须加super.，否则就是无限递归，那么就会栈内存溢出
    }
}

class Father{
    int a = 10;
    int b = 11;
}
class Son extends Father{
    int a = 20;
    
    public void test(){
        //子类与父类的属性同名，子类对象中就有两个a
        System.out.println("子类的a：" + a);//20  先找局部变量找，没有再从本类成员变量找
        System.out.println("子类的a：" + this.a);//20   先从本类成员变量找
        System.out.println("父类的a：" + super.a);//10    直接从父类成员变量找
        
        //子类与父类的属性不同名，是同一个b
        System.out.println("b = " + b);//11  先找局部变量找，没有再从本类成员变量找，没有再从父类找
        System.out.println("b = " + this.b);//11   先从本类成员变量找，没有再从父类找
        System.out.println("b = " + super.b);//11  直接从父类局部变量找
    }
    
    public void method(int a, int b){
        //子类与父类的属性同名，子类对象中就有两个成员变量a，此时方法中还有一个局部变量a		
        System.out.println("局部变量的a：" + a);//30  先找局部变量
        System.out.println("子类的a：" + this.a);//20  先从本类成员变量找
        System.out.println("父类的a：" + super.a);//10  直接从父类成员变量找

        System.out.println("b = " + b);//13  先找局部变量
        System.out.println("b = " + this.b);//11  先从本类成员变量找
        System.out.println("b = " + super.b);//11  直接从父类局部变量找
    }
}
class Test{
    public static void main(String[] args){
        Son son = new Son();
        son.test();
        son.method(30,13);  
    }
}

class A{

}
class B extends A{

}

class Test{
    public static void main(String[] args){
        B b = new B();
        //A类和B类都是默认有一个无参构造，B类的默认无参构造中还会默认调用A类的默认无参构造
        //但是因为都是默认的，没有打印语句，看不出来
    }
}

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{

}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类默认有一个无参构造，
        //B类的默认无参构造中会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"
    }
}

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
    B(){
        System.out.println("B类无参构造器");
    }
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，        
        //B类的无参构造中虽然没有写super()，但是仍然会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器")
    }
}

class A{
    A(){
        System.out.println("A类无参构造器");
    }
}
class B extends A{
    B(){
        super();
        System.out.println("B类无参构造器");
    }
}
class Test{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，        
        //B类的无参构造中明确写了super()，表示调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器")
    }
}

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        System.out.println("B类无参构造器");
    }
}
class Test05{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，        
        //B类的无参构造没有写super(...)，表示默认调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        super();
        System.out.println("B类无参构造器");
    }
}
class Test06{
    public static void main(String[] args){
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，        
        //B类的无参构造明确写super()，表示调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

class A{
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(int a){
        super(a);
        System.out.println("B类有参构造器");
    }
}
class Test07{
    public static void main(String[] args){
        B b = new B(10);
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个有参构造，        
        //B类的有参构造明确写super(a)，表示调用A类的有参构造
        //会打印“A类有参构造器"和"B类有参构造器"
    }
}

class A{
    A(){
        System.out.println("A类无参构造器");
    }
    A(int a){
        System.out.println("A类有参构造器");
    }
}
class B extends A{
    B(){
        super();//可以省略，调用父类的无参构造
        System.out.println("B类无参构造器");
    }
    B(int a){
        super(a);//调用父类有参构造
        System.out.println("B类有参构造器");
    }
}
class Test8{
    public static void main(String[] args){
        B b1 = new B();
        B b2 = new B(10);
    }
}

public class Test{
    public static void main(String[] args){
        Student s = new Student();

        s.eat();
        s.sleep();
        s.study();

        s.show();

        
    }
}

public class Student extends Person{
    
    String school;
    //方法
    public void eat(){
        System.out.println("学生吃饭.....");
    }

    public void sleep(){
        System.out.println("学生睡觉...........");
    }

    public void study(){
        System.out.println("学生认真学习");
    }

    public void show(){
        eat();
        //调用重写的方法

        this.eat();
        //调用本类的方法

        super.eat();
        //调用父类的方法
    }

    public void show1(){
        this.doSport();
        super.doSport();
    }

}

public class Person {
    //属性

    String name;
    private int age;
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
    public void doSport(){
        System.out.println("人运动");
    }
}

public class Test{
    public static void main(String[] args){
        Student s = new Student();

        s.eat();
        s.sleep();
        s.study();

        System.out.println();

        s.show();

        System.out.println();

        Student s1 = new Student();
        s1.show();
        //调用构造器
        Student s2 = new Student("张三", 18, "男");
        s2.show();




    }
}

public class Student extends Person{
    
    String school;
    //方法
    public void eat(){
        System.out.println("学生吃饭.....");
    }

    public void sleep(){
        System.out.println("学生睡觉...........");
    }

    public void study(){
        System.out.println("学生认真学习");
    }

    public void show(){
        eat();
        //调用重写的方法

        this.eat();
        //调用本类的方法

        super.eat();
        //调用父类的方法
    }

    public void show1(){
        this.doSport();
        super.doSport();
    }

    //super调用父类构造器例子
    public Student(){
        super("张三",18);
        System.out.println("Student无参构造器");

    }
    public Student(String name,int age){
        super(name,age);
        System.out.println("Student有2参构造器");
    }
    public Student(String name,int age,String school){
        super(name,age);
        this.school=school;
        System.out.println("Student有3参构造器");
    }


}

public class Person {
    //属性

    String name;
    private int age;
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
    public void doSport(){
        System.out.println("人运动");
    }

    //子类调用父类构造器例子
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("父类1");
    }
    public Person(){
        this.name = "张三";
        this.age = 18;
        System.out.println("父类2");
    }

}

class Parent {
    {
        // 父类的非静态代码块
        System.out.println("Parent's instance initializer");
    }

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

    static {
        // 父类的静态代码块
        System.out.println("Parent's static initializer");
    }
}

class Child extends Parent {
    {
        // 子类的非静态代码块
        System.out.println("Child's instance initializer");
    }

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

    static {
        // 子类的静态代码块
        System.out.println("Child's static initializer");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Memory allocation for Child object");
        Child child = new Child();
    }
}

父类类型 变量名 = 子类对象；

Person p = new Student();

Object o = new Person();//Object类型的变量o，指向Person类型的对象

o = new Student(); //Object类型的变量o，指向Student类型的对象

package com.atguigu.polymorphism.grammar;

public class Pet {
    private String nickname; //昵称

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public void eat(){
        System.out.println(nickname + "吃东西");
    }
}

package com.atguigu.polymorphism.grammar;

public class Cat extends Pet {
    //子类重写父类的方法
    @Override
    public void eat() {
        System.out.println("猫咪" + getNickname() + "吃鱼仔");
    }

    //子类扩展的方法
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

package com.atguigu.polymorphism.grammar;

public class Dog extends Pet {
    //子类重写父类的方法
    @Override
    public void eat() {
        System.out.println("狗子" + getNickname() + "啃骨头");
    }

    //子类扩展的方法
    public void watchHouse() {
        System.out.println("看家");
    }
}

package com.atguigu.polymorphism.grammar;

public class TestPet {
    public static void main(String[] args) {
        //多态引用
        Pet pet = new Dog();
        pet.setNickname("小白");

        //多态的表现形式
        /*
        编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
        运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
         */
        pet.eat();//运行时执行子类Dog重写的方法
//      pet.watchHouse();//不能调用Dog子类扩展的方法

        pet = new Cat();
        pet.setNickname("雪球");
        pet.eat();//运行时执行子类Cat重写的方法
    }
}

package com.atguigu.polymorphism.grammar;

public class Person{
    private Pet pet;
    public void adopt(Pet pet) {//形参是父类类型，实参是子类对象
        this.pet = pet;
    }
    public void feed(){
        pet.eat();//pet实际引用的对象类型不同，执行的eat方法也不同
    }
}

package com.atguigu.polymorphism.grammar;

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

        Dog dog = new Dog();
        dog.setNickname("小白");
        person.adopt(dog);//实参是dog子类对象，形参是父类Pet类型
        person.feed();

        Cat cat = new Cat();
        cat.setNickname("雪球");
        person.adopt(cat);//实参是cat子类对象，形参是父类Pet类型
        person.feed();
    }
}

package com.atguigu.polymorphism.grammar;

public class PetShop {
    //返回值类型是父类类型，实际返回的是子类对象
    public Pet sale(String type){
        switch (type){
            case "Dog":
                return new Dog();
            case "Cat":
                return new Cat();
        }
        return null;
    }
}

package com.atguigu.polymorphism.grammar;

public class TestPetShop {
    public static void main(String[] args) {
        PetShop shop = new PetShop();

        Pet dog = shop.sale("Dog");
        dog.setNickname("小白");
        dog.eat();

        Pet cat = shop.sale("Cat");
        cat.setNickname("雪球");
        cat.eat();
    }
}

public class Dog {
    public void eat(){
        System.out.println("狗啃骨头");
    }
}

public class Cat {
    public void eat(){
        System.out.println("猫吃鱼仔");
    }
}

public class Person {
    private Dog dog;

    //adopt：领养
    public void adopt(Dog dog){
        this.dog = dog;
    }

    //feed：喂食
    public void feed(){
        if(dog != null){
            dog.eat();
        }
    }
    /*
    问题：
    1、从养狗切换到养猫怎么办？   
        修改代码把Dog修改为养猫？
    2、或者有的人养狗，有的人养猫怎么办？  
    3、要是还有更多其他宠物类型怎么办？
    如果Java不支持多态，那么上面的问题将会非常麻烦，代码维护起来很难，扩展性很差。
    */
}

Student m = new Student();
m.school = "pku"; 	//合法,Student类有school成员变量
Person e = new Student(); 
e.school = "pku";	//非法,Person类没有school成员变量

// 属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

Person e = new Student();
e.getInfo();	//调用Student类的getInfo()方法

package com.atguigu.polymorphism.grammar;

public class TestVariable {
    public static void main(String[] args) {
        Base b = new Sub();
        System.out.println(b.a);
        System.out.println(((Sub)b).a);

        Sub s = new Sub();
        System.out.println(s.a);
        System.out.println(((Base)s).a);
    }
}
class Base{
    int a = 1;
}
class Sub extends Base{
    int a = 2;
}

package com.atguigu.polymorphism.grammar;

public class ClassCastTest {
    public static void main(String[] args) {
        //没有类型转换
        Dog dog = new Dog();//dog的编译时类型和运行时类型都是Dog

        //向上转型
        Pet pet = new Dog();//pet的编译时类型是Pet，运行时类型是Dog
        pet.setNickname("小白");
        pet.eat();//可以调用父类Pet有声明的方法eat，但执行的是子类重写的eat方法体
//        pet.watchHouse();//不能调用父类没有的方法watchHouse

        Dog d = (Dog) pet;
        System.out.println("d.nickname = " + d.getNickname());
        d.eat();//可以调用eat方法
        d.watchHouse();//可以调用子类扩展的方法watchHouse

        Cat c = (Cat) pet;//编译通过，因为从语法检查来说，pet的编译时类型是Pet，Cat是Pet的子类，所以向下转型语法正确
        //这句代码运行报错ClassCastException，因为pet变量的运行时类型是Dog，Dog和Cat之间是没有继承关系的
    }
}

class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型，多态
        myAnimal.makeSound(); // 输出 "Woof woof"

        // 向下转型
        if (myAnimal instanceof Dog) {
            Dog myDog = (Dog) myAnimal;
            myDog.makeSound(); // 输出 "Woof woof"
        }
    }
}

if (object instanceof ClassType) {
    // 如果object是ClassType或其子类的实例，则为true
}

class Animal {}
class Dog extends Animal {}

Animal myAnimal = new Dog();
boolean isDog = myAnimal instanceof Dog; // 返回true

if (myAnimal instanceof Dog) {
    Dog myDog = (Dog) myAnimal;
    // 现在可以安全地将myAnimal向下转型为Dog类型，并调用Dog类的方法
}

//检验对象a是否是数据类型A的对象，返回值为boolean型
对象a instanceof 数据类型A 

package com.atguigu.polymorphism.grammar;

public class TestInstanceof {
    public static void main(String[] args) {
        Pet[] pets = new Pet[2];
        pets[0] = new Dog();//多态引用
        pets[0].setNickname("小白");
        pets[1] = new Cat();//多态引用
        pets[1].setNickname("雪球");

        for (int i = 0; i < pets.length; i++) {
            pets[i].eat();

            if(pets[i] instanceof Dog){
                Dog dog = (Dog) pets[i];
                dog.watchHouse();
            }else if(pets[i] instanceof Cat){
                Cat cat = (Cat) pets[i];
                cat.catchMouse();
            }
        }
    }
}

class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    public void watchDoor() {
        System.out.println("Dog is watching the door");
    }
}

class Cat extends Animal {
    public void catchMouse() {
        System.out.println("Cat is catching a mouse");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal;

        // 假设animal被赋值为Dog或Cat的对象
        animal = new Dog();
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchDoor();
        } else if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        // 再次改变animal的类型
        animal = new Cat();
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchDoor();
        } else if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

class Base {
    int count = 10;
    public void display() {
        System.out.println(this.count);
    }
}

class Sub extends Base {
    int count = 20;
    public void display() {
        System.out.println(this.count);
    }
}

public class FieldMethodTest {
    public static void main(String[] args){
        Sub s = new Sub();
        System.out.println(s.count);
        s.display();
        Base b = s;
        System.out.println(b == s);
        System.out.println(b.count);
        b.display();
    }
}

//考查多态的笔试题目：
public class InterviewTest1 {

    public static void main(String[] args) {
        Base base = new Sub();
        base.add(1, 2, 3);

//		Sub s = (Sub)base;
//		s.add(1,2,3);
    }
}

class Base {
    public void add(int a, int... arr) {
        System.out.println("base");
    }
}

class Sub extends Base {

    public void add(int a, int[] arr) {
        System.out.println("sub_1");
    }

//	public void add(int a, int b, int c) {
//		System.out.println("sub_2");
//	}

}

//getXxx()和setXxx()声明在哪个类中，内部操作的属性就是哪个类里的。
public class InterviewTest2 {
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        System.out.println(f.getInfo());//atguigu
        System.out.println(s.getInfo());//尚硅谷
        s.test();//尚硅谷  atguigu
        System.out.println("-----------------");
        s.setInfo("大硅谷");
        System.out.println(f.getInfo());//atguigu
        System.out.println(s.getInfo());//大硅谷
        s.test();//大硅谷  atguigu
    }
}

class Father {
    private String info = "atguigu";

    public void setInfo(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }
}

class Son extends Father {
    private String info = "尚硅谷";
    
    public void setInfo(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }
    
    public void test() {
        System.out.println(this.getInfo());
        System.out.println(super.getInfo());
    }
}

//证明如下：
class Animal  {
    protected void eat() {
        System.out.println("animal eat food");
    }
}

class Cat  extends Animal  {
    protected void eat() {
        System.out.println("cat eat fish");
    }
}

class Dog  extends Animal  {
    public void eat() {
        System.out.println("Dog eat bone");
    }
}

class Sheep  extends Animal  {
    public void eat() {
        System.out.println("Sheep eat grass");
    }
}

public class InterviewTest {
    public static Animal  getInstance(int key) {
        switch (key) {
        case 0:
            return new Cat ();
        case 1:
            return new Dog ();
        default:
            return new Sheep ();
        }

    }

    public static void main(String[] args) {
        int key = new Random().nextInt(3);
        System.out.println(key);

        Animal  animal = getInstance(key);
        animal.eat(); 
    }
}

class Person {
    protected String name="person";
    protected int age=50;
    public String getInfo() {
              return "Name: "+ name + "\n" +"age: "+ age;
    }
}
class Student extends Person {
    protected String school="pku";
    public String getInfo() {
                return  "Name: "+ name + "\nage: "+ age 
              + "\nschool: "+ school;
    }	
}
class Graduate extends Student{
    public String major="IT";
    public String getInfo()
    {
        return  "Name: "+ name + "\nage: "+ age 
              + "\nschool: "+ school+"\nmajor:"+major;
    }
}

method(Object obj){…} //可以接收任何类作为其参数

Person o = new Person();  
method(o);

public class Person {
    ...
}
//等价于：
public class Person extends Object {
    ...
}

public class UserTest {

    public static void main(String[] args) {
        User user = new User("adouzi", 18);
        User user2 = new User("adouzi", 18);

        System.out.println(user.equals(user2));
        // 输出结果为false

        /*
         * public boolean equals(Object obj) {
         * return (this == obj);
         * }
         */

        String str1 = new String("adouzi");
        String str2 = new String("adouzi");

        System.out.println(str1.equals(str2));
        // 输出结果为true

        /*
         * 
         * public boolean equals(Object anObject) {
         * if (this == anObject) {
         * return true;
         * }
         * return (anObject instanceof String aString)
         * && (!COMPACT_STRINGS || this.coder == aString.coder)
         * && StringLatin1.equals(value, aString.value);
         * }
         */

    }
}

class User {
    String name;
    int age;

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

}

public boolean equals(Object obj) {
        return (this == obj);
}

String str1 = new String("adouzi");
String str2 = new String("adouzi");

System.out.println(str1.equals(str2));
         //输出结果为true

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        return (anObject instanceof String aString)
                && (!COMPACT_STRINGS || this.coder == aString.coder)
                && StringLatin1.equals(value, aString.value);
    }

//重写equals方法
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof User) {
            User user = (User) obj;
            return this.name.equals(user.name);
        }
        return false;
        
    }

public class UserTest {

    public static void main(String[] args) {
        User user = new User("adouzi", 18);
        User user2 = new User("adouzi", 18);

        System.out.println(user.equals(user2));
        // 输出结果为false
        //重写后输出结果为true

        /*
         * public boolean equals(Object obj) {
         * return (this == obj);
         * }
         */

        String str1 = new String("adouzi");
        String str2 = new String("adouzi");

        System.out.println(str1.equals(str2));
        // 输出结果为true

        /*
         * 
         * public boolean equals(Object anObject) {
         * if (this == anObject) {
         * return true;
         * }
         * return (anObject instanceof String aString)
         * && (!COMPACT_STRINGS || this.coder == aString.coder)
         * && StringLatin1.equals(value, aString.value);
         * }
         */

    }
}

class User {
    String name;
    int age;

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

    //重写equals方法
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof User) {
            User user = (User) obj;
            return this.name.equals(user.name);
        }
        return false;
        
    }

}

String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

System.out.println(s1 == s2); // true，因为s1和s2指向JVM字符串常量池中的同一个对象
System.out.println(s1 == s3); // false，因为s1指向字符串常量池中的对象，而s3指向堆中的新对象

String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

System.out.println(s1.equals(s2)); // true，因为equals()比较的是字符串的内容
System.out.println(s1.equals(s3)); // true，因为equals()比较的是字符串的内容

int a=5; 
if(a==6){…}

Person p1=new Person();  	    
Person p2=new Person();
if (p1==p2){…}

class User{
    private String host;
    private String username;
    private String password;
    public User(String host, String username, String password) {
        super();
        this.host = host;
        this.username = username;
        this.password = password;
    }
    public User() {
        super();
    }
    public String getHost() {
        return host;
    }
    public void setHost(String host) {
        this.host = host;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [host=" + host + ", username=" + username + ", password=" + password + "]";
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (host == null) {
            if (other.host != null)
                return false;
        } else if (!host.equals(other.host))
            return false;
        if (password == null) {
            if (other.password != null)
                return false;
        } else if (!password.equals(other.password))
            return false;
        if (username == null) {
            if (other.username != null)
                return false;
        } else if (!username.equals(other.username))
            return false;
        return true;
    }
    
}

int it = 65;
float fl = 65.0f;
System.out.println(“65和65.0f是否相等？” + (it == fl)); //

char ch1 = 'A'; char ch2 = 12;
System.out.println("65和'A'是否相等？" + (it == ch1));//
System.out.println("12和ch2是否相等？" + (12 == ch2));//

String str1 = new String("hello");
String str2 = new String("hello");
System.out.println("str1和str2是否相等？"+ (str1 == str2));//

System.out.println("str1是否equals str2？"+(str1.equals(str2)));//

System.out.println(“hello” == new java.util.Date()); //

public class EqualsTest {
    public static void main(String[] args) {
        MyDate m1 = new MyDate(14, 3, 1976);
        MyDate m2 = new MyDate(14, 3, 1976);
        if (m1 == m2) {
            System.out.println("m1==m2");
        } else {
            System.out.println("m1!=m2"); // m1 != m2
        }

        if (m1.equals(m2)) {
            System.out.println("m1 is equal to m2");// m1 is equal to m2
        } else {
            System.out.println("m1 is not equal to m2");
        }
    }
}

public class ToStringTest {
    public static void main(String[] args) {
        User user = new User("张三", 20);
        System.out.println(user.toString());
    }
    
}

class User {
    String name;
    int age;

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

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

Date now=new Date();
System.out.println(“now=”+now);  //相当于
System.out.println(“now=”+now.toString()); 

s1="hello";
System.out.println(s1);//相当于System.out.println(s1.toString());

public class Person {  
    private String name;
    private int age;

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

//Object类的clone()的使用
public class CloneTest {
    public static void main(String[] args) {
        Animal a1 = new Animal("花花");
        try {
            Animal a2 = (Animal) a1.clone();
            System.out.println("原始对象：" + a1);
            a2.setName("毛毛");
            System.out.println("clone之后的对象：" + a2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

class Animal implements Cloneable{
    private String name;

    public Animal() {
        super();
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Animal [name=" + name + "]";
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }
    
}

public class FinalizeTest {
    public static void main(String[] args) {
        Person p = new Person("Peter", 12);
        System.out.println(p);
        p = null;//此时对象实体就是垃圾对象，等待被回收。但时间不确定。
        System.gc();//强制性释放空间
    }
}

class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        super();
        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
    protected void finalize() throws Throwable {
        System.out.println("对象被释放--->" + this);
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
}