继承与多态：面向对象编程的两大支柱

引言：为什么必须掌握继承与多态？

在Java开发中，继承与多态是构建可扩展、易维护系统的基石：

• 继承：实现代码复用，建立清晰的类层次结构
• 多态：提升代码灵活性，实现"编写一次，到处运行"
• 框架基础：Spring等框架大量使用多态实现依赖注入

一、extends关键字：构建类层次结构

1.1 继承的必要性

// 错误示范：重复代码
class Dog {
    void eat() { System.out.println("Dog eats"); }
}

class Cat {
    void eat() { System.out.println("Cat eats"); }
}

继承优化后：

class Animal {
    void eat() { System.out.println("Animal eats"); }
}

class Dog extends Animal {} // 自动继承eat方法
class Cat extends Animal {}

1.2 extends核心规则

语法结构：

class SubClass extends SuperClass {
    // 新增/重写方法
}

关键限制：

• Java仅支持单继承（可通过接口实现多继承）
• 子类构造函数必须调用父类构造函数（显式/隐式）

执行顺序：

class Parent {
    Parent() { 
        System.out.println("Parent constructor"); 
    }
}

class Child extends Parent {
    Child() {
        super(); // 隐式调用
        System.out.println("Child constructor");
    }
}

// 输出顺序：
// Parent constructor
// Child constructor

1.3 继承中的访问控制

修饰符	本类	同包	子类	其他包
public	✔️	✔️	✔️	✔️
protected	✔️	✔️	✔️	❌
default	✔️	✔️	❌	❌
private	✔️	❌	❌	❌

二、方法重写与@Override注解

2.1 方法重写的必要性

场景示例：

class Shape {
    void draw() {
        System.out.println("Drawing shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() { // 实现具体图形绘制
        System.out.println("Drawing circle");
    }
}

核心价值：

• 保持接口一致性，实现多态
• 子类自定义实现细节
• 遵循开闭原则（对扩展开放，对修改关闭）

2.2 重写规则验证

class Parent {
    protected Number calculate(int a) throws Exception {
        return a * 2;
    }
}

class Child extends Parent {
    @Override
    public Integer calculate(int a) { // 合法重写
        return a * 3;
    }
}

规则清单：

1. 方法名、参数列表必须完全相同
2. 返回类型兼容（协变返回类型）
3. 访问权限不能更严格
4. 抛出异常不能更广泛

2.3 @Override注解详解

三大作用：

1. 编译器检查：确保方法正确重写
2. 代码可读性：明确标识重写方法
3. 维护保障：父类方法修改时及时报错

反例警示：

class Child extends Parent {
    // 误写为calcultae（拼写错误）
    void calcultae(int a) { ... } // 不会触发重写
}

三、动态绑定：多态的实现基石

3.1 动态绑定的必要性

经典案例：

Animal myPet = new Dog();
myPet.eat(); // 实际执行Dog的eat方法

myPet = new Cat();
myPet.eat(); // 自动切换为Cat的eat方法

核心价值：

• 运行时决定方法实现
• 实现接口与实现分离
• 支持插件式架构设计

3.2 JVM实现原理

执行流程：

1. 对象创建时确定实际类型（Dog/Cat）
2. 方法调用通过虚方法表（VMT）查找
3. 调用invokevirtual字节码指令

内存结构：

类型指针

Object

+__proto__: Class

Class

+vtable: Method[]

3.3 静态绑定对比

静态绑定场景：

• private/final/static方法
• 构造函数调用
• 对象强制类型转换

性能差异：

• 静态绑定：直接地址调用（更快）
• 动态绑定：需要查表（约10%性能损耗）

四、工程实践建议

1. 组合优于继承：优先使用组合实现代码复用

   class Vehicle {
       Engine engine = new Engine(); // 组合方式
   }
   

2. 模板方法模式：

   abstract class AbstractProcessor {
       final void process() {
           validate();
           execute();
       }
       abstract void execute();
       void validate() { /* 默认实现 */ }
   }
   

3. Liskov替换原则：子类必须完全替代父类

4. 避免方法过度重写：通过final关键字限制重写

总结

继承与多态是面向对象编程的核心机制，掌握extends关键字的正确使用、方法重写的规范以及动态绑定的底层原理，能够显著提升代码的可维护性和扩展性。在实际开发中，应合理设计类层次结构，善用多态特性，同时注意遵循设计原则避免滥用继承，最终构建出灵活、健壮的软件系统。