一、面向对象的两大支柱

在面向对象编程的殿堂中，**继承**与**多态**如同DNA双螺旋，共同构建了代码的灵活性与扩展性。它们是实现代码复用和抽象的核心机制，如同乐高积木的通用接口，让不同组件能够无缝协作。

二、继承：代码复用的基因传递

1. 继承的本质
- 类层级复制：子类自动获得父类属性和方法
- 差异化进化：通过添加新特性或修改现有行为实现扩展
- 语法基因：`extends`关键字建立继承关系

```java
// 生物基类
class LivingBeing {
void breathe() {
System.out.println("进行呼吸");
}
}

// 动物子类
class Animal extends LivingBeing {
void move() {
System.out.println("自由移动");
}
}

// 鸟类子类
class Bird extends Animal {
@Override
void move() {
System.out.println("展翅飞翔");
}

void layEggs() {
System.out.println("产卵繁殖");
}
}
```

2. 继承的三大法则
1. 单继承限制：Java不支持多重继承（但可通过接口实现）
2. 构造方法链：子类构造器必须调用父类构造器（显式或隐式）
3. 访问权限传递：子类不能获得父类的private成员

3. 方法重写（Override）的奥秘
```java
class Payment {
void process() {
System.out.println("基础支付流程");
}
}

class Alipay extends Payment {
@Override
void process() {
System.out.println("支付宝扫码支付");
super.process(); // 调用父类实现
}
}
```

| 重写 vs 重载 | 方法重写 (Override) | 方法重载 (Overload) |
|------------------|--------------------------------|------------------------------|
| 发生位置 | 父子类之间 | 同一类中 |
| 参数列表 | 必须完全相同 | 必须不同 |
| 返回类型 | 兼容（相同或子类） | 可自由变化 |
| 访问权限 | 不能更严格 | 无限制 |
| 异常声明 | 不能抛出更宽泛的检查型异常 | 无限制 |

三、多态：同一接口的千面演绎

1. 多态的双重形态
- 编译时多态：方法重载（静态绑定）
- 运行时多态：方法重写（动态绑定）

2. 对象变形的魔法
```java
Payment pay = new Alipay(); // 向上转型
pay.process(); // 实际调用子类方法

List<Animal> zoo = new ArrayList<>();
zoo.add(new Dog());
zoo.add(new Cat());
zoo.forEach(Animal::move); // 不同子类不同行为
```

3. 多态实现的三大要素
1. 继承关系：存在父子类层级
2. 方法重写：子类修改父类行为
3. 向上转型：父类引用指向子类对象

四、继承与多态的协同作战

1. 抽象类与接口
```java
// 抽象类：包含未实现方法
abstract class Shape {
abstract double area();

void printArea() {
System.out.println("面积：" + area());
}
}

// 接口：纯行为规范
interface Drawable {
void draw();
default void resize() { /* Java8新特性 */ }
}

class Circle extends Shape implements Drawable {
@Override
double area() { return Math.PI * radius * radius; }

@Override
public void draw() { System.out.println("绘制圆形"); }
}
```

2. 类型系统的四维空间

| 类型 | 抽象类 | 接口 |
|----------------|--------------------------------|------------------------------|
| 实例化 | 不能直接实例化 | 不能直接实例化 |
| 方法实现 | 可包含具体方法 | Java8+支持默认方法 |
| 变量类型 | 只能继承一个 | 可实现多个 |
| 设计目的 | 代码复用 | 行为规范 |
| 构造器 | 有 | 无 |
| 访问控制 | 任意访问修饰符 | 默认public |

五、高级技巧与最佳实践

1. 构造方法调用链
```java
class GrandParent {
GrandParent() { System.out.println("爷爷构造器"); }
}

class Parent extends GrandParent {
Parent() {
super(); // 隐含调用
System.out.println("父亲构造器");
}
}

class Child extends Parent {
Child() {
System.out.println("孩子构造器");
}
}
// 输出顺序：爷爷 → 父亲 → 孩子
```

2. 防御性编程策略
1. final终结者：防止继承或方法重写
```java
public final class UtilityClass { /* 工具类 */ }
```

2. 模板方法模式：固定算法骨架
```java
abstract class Game {
final void play() { // 不可重写的模板方法
initialize();
startPlay();
endPlay();
}

abstract void initialize();
abstract void startPlay();
// ...省略其他方法
}
```

3. 多态在集合中的应用
```java
List<Shape> shapes = Arrays.asList(
new Circle(5),
new Rectangle(3,4),
new Triangle(3,4,5)
);

shapes.forEach(shape ->
System.out.println(shape.getClass().getSimpleName()
+ " 面积：" + shape.area()));
```

六、常见陷阱警示

1. 菱形继承问题
```java
// 伪代码演示错误情况
class A { void test() {} }
class B extends A { @Override void test() {} }
class C extends A { @Override void test() {} }
// class D extends B, C {} // Java不允许
```

2. 脆弱的基类问题
- 父类修改可能破坏所有子类
- 解决方案：优先使用组合而非继承

3. 类型转换异常
```java
Animal animal = new Cat();
Dog dog = (Dog)animal; // ClassCastException
```

4. 静态方法陷阱
```java
class Parent {
static void method() { System.out.println("Parent"); }
}

class Child extends Parent {
static void method() { System.out.println("Child"); }
}

Parent obj = new Child();
obj.method(); // 输出Parent（静态方法没有多态性！）
```

七、总结

继承构建层次，多态实现弹性。好的面向对象设计应该像生态系统——各类生物（对象）各司其职，通过遗传（继承）保持共性，通过变异（多态）展现个性，最终形成稳定而富有生命力的代码生态。