一句话说透Java里面的继承、封装、多态

一句话总结：
继承是“子承父业”，封装是“黑箱操作”，多态是“千人千面”——面向对象三大法宝，让代码更灵活、更安全、更好复用！

---

一、继承（Inheritance）——子承父业

比喻：儿子继承老爸的财产（属性和方法），还能自己创业（扩展新功能）。

怎么用？

// 老爸类（基类）  
class Father {  
    String surname = "张";  
    void drive() {  
        System.out.println("开五菱宏光");  
    }  
}  

// 儿子类（子类）继承老爸  
class Son extends Father {  
    // 继承 surname 和 drive()  
    void playGame() {  
        System.out.println("打王者农药"); // 扩展新方法  
    }  
}  

public static void main(String[] args) {  
    Son son = new Son();  
    son.drive();     // 输出：开五菱宏光（继承来的）  
    son.playGame();  // 输出：打王者农药（自己新增的）  
}  

核心作用：

1. 代码复用：不用重复写老爸的代码。
2. 层次化设计：父子类形成树状结构（如动物 → 猫 → 布偶猫）。

注意！

• 不要滥用继承：比如“苹果”继承“水果”合理，但“苹果”继承“卡车”就离谱！
• Java是单继承：一个类只能有一个亲爹（用接口实现多继承效果）。

---

二、封装（Encapsulation）——黑箱操作

比喻：像用微波炉——你只管按键，不用知道内部怎么加热。

怎么用？

1. 用 private 保护字段：外部不能直接修改。
2. 用 getter/setter 控制访问：加验证逻辑，比如年龄不能为负数。

class BankAccount {  
    private double balance; // 余额私有化  

    // 通过方法操作余额  
    public void deposit(double money) {  
        if (money > 0) {  
            balance += money;  
        }  
    }  

    public double getBalance() {  
        return balance;  
    }  
}  

public static void main(String[] args) {  
    BankAccount account = new BankAccount();  
    account.deposit(1000);  
    // account.balance = -9999;  // 报错！不能直接访问  
    System.out.println(account.getBalance());  
}  

核心作用：

1. 数据安全：防止外部随意篡改（比如余额不能直接设负数）。
2. 隐藏复杂度：使用者只需关注方法，不用关心内部实现。

---

三、多态（Polymorphism）——千人千面

比喻：同一个“叫”的方法，猫是“喵”，狗是“汪”——具体表现看对象类型。

实现方式：

1. 继承 + 方法重写：子类重写父类方法。
2. 接口 + 实现类：不同类实现同一接口。

代码示例：

// 父类 Animal  
class Animal {  
    void shout() {  
        System.out.println("叫");  
    }  
}  

// 子类重写方法  
class Cat extends Animal {  
    @Override  
    void shout() {  
        System.out.println("喵~");  
    }  
}  

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

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

    a1.shout(); // 输出：喵~  
    a2.shout(); // 输出：汪！  
}  

核心作用：

1. 代码扩展性：新增动物类型（如鸭子）不用改原有代码。
2. 统一接口：用父类类型处理不同子类对象（如遍历动物数组统一调用 shout()）。

---

三大特性总结表

特性	比喻	核心思想	应用场景
继承	子承父业	代码复用，层次化设计	扩展已有类（如猫继承动物）
封装	黑箱操作	隐藏细节，保护数据	保护敏感数据（如银行余额）
多态	千人千面	同一方法不同实现	统一处理不同子类对象

---

常见坑点！

1. 继承滥用：

   • 错误：为了复用代码，让不相关的类强行继承。
   • 正确：优先用组合（把类作为成员变量）替代继承。

2. 封装失效：

   • 错误：用 public 暴露字段，允许直接修改。
   • 正确：字段尽量 private，通过方法控制访问。

3. 多态误解：

   • 错误：认为 Animal a = new Cat(); 后，a 能直接调用 Cat 独有的方法（如 catchMouse()）。
   • 正确：需要强制类型转换：((Cat)a).catchMouse();（先检查类型）。

---

总结口诀：

“封装藏细节，继承省代码。
多态玩花样，对象变魔术。
三大特性配合好，面向对象真奇妙！”