封装、继承、多态

面向对象三大特性：封装、继承、多态。

1. 封装

把字段设为 private，通过 getter/setter 方法访问，可以控制字段的读写。

public class BankAccount {
    private double balance;   // 私有字段，外部无法直接访问

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {      // 加一层校验
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(1000);
        account.withdraw(300);
        System.out.println(account.getBalance());   // 700.0

        // account.balance = -100;  // 编译报错：private 字段不能直接访问
    }
}

好处：外部只能通过方法操作，避免了非法数据（比如余额变负数）。

2. 继承

用 extends 让一个类继承另一个类，子类自动获得父类的字段和方法。

// 父类
public class Animal {
    String name;

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

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println(name + "汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";      // 继承来的字段
        dog.eat();               // 继承来的方法：旺财在吃东西
        dog.bark();              // 自己的方法：旺财汪汪叫
    }
}

要点：

• Java 是单继承，一个类只能继承一个父类
• 所有类默认继承 Object

3. 方法重写（override）

子类重写父类的方法，用 @Override 标注。

public class Animal {
    public void makeSound() {
        System.out.println("动物叫");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound();   // 汪汪

        Animal cat = new Cat();
        cat.makeSound();   // 喵喵
    }
}

4. super 关键字

super 指父类，用来调用父类的构造方法或方法。

public class Animal {
    String name;

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

    public void makeSound() {
        System.out.println("动物叫");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);   // 调用父类的构造方法
    }

    @Override
    public void makeSound() {
        super.makeSound();       // 先调用父类的方法
        System.out.println(name + "汪汪");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        dog.makeSound();
        // 动物叫
        // 旺财汪汪
    }
}

5. 多态

父类引用指向子类对象，调用方法时执行子类的重写方法。同一个调用，表现不同，就是多态。

public class Main {
    public static void main(String[] args) {
        // 父类引用指向不同的子类对象
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        a1.makeSound();   // 汪汪
        a2.makeSound();   // 喵喵

        // 多态的好处：可以用统一的方式处理不同子类
        Animal[] animals = {new Dog(), new Cat(), new Dog()};
        for (Animal a : animals) {
            a.makeSound();
        }
    }
}

6. final 关键字

• final 修饰类：不能被继承
• final 修饰方法：不能被重写
• final 修饰变量：值不能改（常量）

public class Demo {
    public static void main(String[] args) {
        final int MAX = 100;
        // MAX = 200;   // 编译报错：final 变量不能重新赋值

        final String name = "Java";
        // name = "Python";   // 编译报错
    }
}

小结

• 封装：private 字段 + getter/setter，保护数据
• 继承：extends 复用代码，单继承
• 多态：父类引用指向子类对象，方法调用看实际对象
• super 调用父类，final 禁止继承/重写/修改