Java 继承与多态：从"能用"到"精通"，更深一层的原理与设计思维
前一篇像是在告诉你"继承和多态怎么写、容易写错什么"。
这一篇往前走一步：为什么这么设计？Java 背后的模型是什么？哪些写法在业务代码里没问题，但在大型工程中是灾难？哪些"看似自然的继承"，其实应该用组合？多态为什么被称为"面向对象的灵魂"？
这篇内容更偏向思维框架、原理与设计方法，而不是单纯的语法罗列。
一、继承的本质：让"共性"上移，让"变化"下沉
继承解决的不是"代码能不能运行"，而是：
把稳定、通用的行为上移到父类，把随业务变化的行为留在子类。
这样带来的最大收益是：变化收敛。
举个例子：
如果系统里新增一个 PPTWriter，你要改多少行代码？
不使用继承时，很易出现这样的模式：
java
if(type == 1) writePDF();
else if(type == 2) writeExcel();
else if(type == 3) writeWord();每增加一种类型，就要修改已有代码，这叫：
对修改开放，对扩展封闭（这正是坏设计）。
继承体系下：
java
abstract class Writer {
public abstract void write();
}
class PDFWriter extends Writer {
public void write() { ... }
}调用端永远长这样：
java
public void doWrite(Writer w){
w.write(); // 永远不变
}新增类型？
写一个子类就完事了，不需要动调用代码。
这才是继承真正的价值：使调用端永远稳定，让变化从外部迁移到内部。
二、继承的代价：它会"锁死"你的设计
继承不是"强大"，而是"危险"。因为一旦继承了，你的类型体系就注定要承担几个后果：
1. 类型关系被锁死（IS-A 必须永远成立）
你写了：
java
class Dog extends Animal {}就意味着：
在整个系统生命周期中，"狗是一种动物"必须逻辑上永远成立。
问题在于，很多我们以为合理的继承关系，放到真实业务中并不合理。
例如：
java
class Square extends Rectangle {}数学上"正方形是特殊长方形"，但程序设计上，"长宽可独立修改" vs "必须保持长宽一致"会导致大量不一致，继承反而破坏安全性。
结论：
继承用于表达真正的结构层次，而不是"看起来像"。
如果无法完全保证结构一致性，就该用组合。
2. 可见性扩大，耦合提升
继承会让子类拥有父类几乎所有非 private 的东西，导致：
- 子类对父类强依赖
- 父类的修改会影响所有子类
- 体系越大，牵一发而动全身
这就是为什么很多框架会把类设计为 final（例如 String）。
三、覆盖与隐藏：多态的细节与陷阱
写 Java 时经常听到：
"属性没有多态，方法有多态。"
我们详细看看 JVM 是怎么做决策的。
1. 调用字段：编译器直接决定（静态绑定）
java
class A { int num = 1; }
class B extends A { int num = 2; }
A a = new B();
System.out.println(a.num); // 输出 1这是因为字段访问不走虚方法表，属于"静态绑定"。
字段永远按"引用类型"来决定，不看实际对象。
2. 调用方法：运行时决定（动态绑定）
当你调用：
java
a.run();JVM 会按照以下流程：
- 根据引用类型（A）去它的方法表查
run - 如果是虚方法（非 static / final / private）
- 根据对象的实际类型（B）去虚方法表定位最终方法
- 调用 B 的版本
这就是所谓的"动态绑定"。
3. "重写" vs "隐藏"：不是所有同名方法都是多态
不能重写的成员：
- static 方法（静态绑定）
- private 方法（子类根本看不到）
- final 方法（故意禁止重写）
- 构造方法（不属于继承体系）
如果子类写了同名方法，这叫"隐藏"，不是"重写"。
例如：
java
class A {
static void hi(){ System.out.println("A"); }
}
class B extends A {
static void hi(){ System.out.println("B"); }
}
A a = new B();
a.hi(); // 输出 A，不是 B因为 static 方法根本不具备多态性。
四、多态的核心价值不是"语法"，而是"可扩展性"
多态的最大价值不是让你少写一个 if，而是：
新增行为不需要修改旧代码。
这是一种结构性收益，是系统级的，而不是语法级的。
你写过的每一个可扩展模块、插件系统、策略模式、工厂模式，本质都是在利用多态。
一个简化的例子：
java
interface Algorithm {
int run(int input);
}你可以轻松扩展：
- NewAlgorithmA
- FastAlgorithmB
- GPUAlgorithmC
调用端永远不变化：
java
public void execute(Algorithm algo){
algo.run(100);
}这是多态真正的魔法：隔离不变与变化。
五、更深一层：多态并不局限于"继承"，它是一种思想
多态常被误解成"父类引用指向子类对象"。
那是 Java 的一种实现方式，而不是多态本身。
多态的实质是：
通过同一接口访问不同的行为。
例如函数式接口 / Lambda 在 Java 8 之后提供的多态：
java
Runnable r = () -> System.out.println("Hello");
Thread t = new Thread(r);这里完全没有子类，只有接口＋行为对象，多态照样成立。
更高级的例子是"鸭子类型"（Duck Typing），在 Python 中常见：
"只要会叫鸭子叫，就当成鸭子。"
方法名相同即可形成多态，与继承无关。
Java 因为是静态类型语言，不能直接玩鸭子类型，但通过接口、泛型、lambda 可以实现同样的思想。
六、构造器调用子类重写方法：为什么这是坑？
这是一个经典"隐藏炸弹"：
java
class A {
A() { test(); }
void test(){ System.out.println("A"); }
}
class B extends A {
int x = 10;
B() {}
void test(){ System.out.println(x); }
}
new B(); // 输出什么？ → 0原因很简单：
- 父类构造器先执行
- 父类构造器调用被重写的方法
- 此时子类对象还没初始化，x 还是默认值 0
这就是为什么很多语言（例如 C++）禁止构造器调用虚方法。
Java 允许，但会留下这种容易混淆的 bug。
七、继承与多态设计的黄金法则（真正工程级经验）
这是设计扩展性系统时非常管用的几条原则：
1. 能用组合就不用继承
组合比继承更灵活，也更安全。
例如不要让 ArrayList 继承 Array，而是让它内部"has a array"。
2. 继承用于表达稳定结构，而不是为了复用代码
复用行为用组合更合理。
继承必须表达真实的"is-a"。
3. 避免深层继承结构
继承链超过 3 层，阅读和维护成本急剧上升。
4. 父类必须尽可能稳定，否则整个体系跟着动
这叫："父类变化，子类地震"。
5. 构造方法不要调用可被重写的方法
因为对象还没初始化完毕。
6. 接口 + 多态 远优于抽象类 + 多态
接口提供更柔性的扩展能力。
八、总结：继承是结构，多态是灵魂，接口是未来
继承让你塑造类型体系，多态让你构建可扩展系统，而接口让整个系统摆脱继承链的束缚。
继承是一把利剑，但用不好，会割伤自己；
多态是设计的基石，它提供了一种"以不变应万变"的思维方式；
接口则是现代 Java 设计的核心，让行为组合比类型层次更重要。