1. 为什么需要继承：代码复用的本质
我第一次真正理解继承的价值，是在维护一个老旧的Java项目时。当时系统中有几十个相似的实体类，每个类都重复定义了id、createTime、updateTime这些字段，以及对应的getter/setter方法。每次修改基础字段都要在所有类中同步变更，这种重复劳动让我开始思考：面向对象难道就是为了制造样板代码吗？
继承机制的出现，完美解决了这个问题。通过将公共属性和行为抽取到父类中，子类只需关注自身特有的部分。这种"is-a"关系（子类是父类的一种）是面向对象设计的基石。举个例子，电商系统中的User和Admin都可以继承自BaseUser：
java复制class BaseUser {
private Long id;
private String username;
// 公共getter/setter
}
class User extends BaseUser {
private Integer creditLevel; // 用户特有属性
}
class Admin extends BaseUser {
private String department; // 管理员特有属性
}
关键经验：当发现多个类有超过30%的重复代码时，就该考虑使用继承了。但要注意，继承层次不宜过深（建议不超过3层），否则会带来维护复杂度。
2. 继承的核心语法与规则
2.1 extends关键字的使用
Java中使用extends关键字实现继承，语法看似简单却暗藏玄机：
java复制class Parent {
protected String familyName = "张";
}
class Child extends Parent {
void printName() {
System.out.println(familyName); // 可直接访问父类protected成员
}
}
这里有个容易踩的坑：子类构造方法中必须首先调用父类构造器。如果父类没有无参构造器，必须用super()显式调用：
java复制class Parent {
Parent(String name) { /*...*/ }
}
class Child extends Parent {
Child() {
super("默认名称"); // 必须显式调用
// 子类初始化代码...
}
}
2.2 访问控制的关键细节
访问修饰符在继承中表现特殊：
private成员：子类不可见（编译错误）default成员：同包子类可见protected成员：任意子类可见public成员：全局可见
一个实际项目中的教训：我曾将父类字段设为private却忘记提供getter，导致子类无法访问。正确的做法是：
java复制class Parent {
protected String importantField; // 或提供protected getter
}
2.3 方法重写的限制条件
重写(Override)不是随意为之，必须遵守以下规则：
- 方法名、参数列表必须完全相同
- 返回类型可以是原类型的子类（协变返回）
- 访问权限不能比父类更严格
- 不能抛出比父类更宽泛的异常
java复制class FileParser {
public InputStream parse() throws IOException { /*...*/ }
}
class AdvancedParser extends FileParser {
@Override
public FileInputStream parse() throws FileNotFoundException {
// 允许缩小异常范围和返回子类型
}
}
3. 继承的内存模型深度解析
3.1 对象创建的完整过程
当执行new Child()时，JVM会完成以下操作：
- 加载父类和子类的Class对象
- 在堆中分配内存空间（包含父类和子类所有字段）
- 递归初始化父类静态块
- 初始化子类静态块
- 执行父类实例初始化块和构造器
- 执行子类实例初始化块和构造器
通过HSDB工具查看内存布局，可以看到：
code复制Child对象实例:
+-------------------+
| Parent fields |
|-------------------|
| Child fields |
+-------------------+
3.2 方法调用的底层原理
方法调用涉及JVM的方法表机制：
- 每个类都有虚方法表(vtable)
- 非private、非static、非final的方法会出现在vtable中
- 调用时通过对象头的类型指针找到实际类的方法表
示例分析：
java复制class Animal {
void speak() { System.out.println("..."); }
}
class Dog extends Animal {
@Override void speak() { System.out.println("Wang!"); }
}
Animal a = new Dog();
a.speak(); // 输出"Wang!"
JVM执行步骤：
- 检查a的实际类型是Dog
- 查找Dog类的speak方法
- 执行Dog.speak()
3.3 字段访问的特殊情况
字段访问与方法调用不同，是静态绑定的：
java复制class Parent {
String name = "Parent";
}
class Child extends Parent {
String name = "Child";
}
Parent p = new Child();
System.out.println(p.name); // 输出"Parent"!
这是因为字段访问在编译期就确定了，不会像方法调用那样动态查找。实际项目中要特别注意这种差异。
4. 继承的进阶话题与最佳实践
4.1 组合与继承的选择
继承不是银弹。当遇到以下情况时，应该优先考虑组合：
- 需要复用代码但不符合"is-a"关系
- 父类会被频繁修改
- 需要同时复用多个类的功能
示例：用组合实现策略模式
java复制class PaymentProcessor {
private PaymentStrategy strategy;
void setStrategy(PaymentStrategy s) {
this.strategy = s;
}
void process() {
strategy.execute();
}
}
4.2 模板方法模式实战
继承的经典应用场景：模板方法模式
java复制abstract class ReportGenerator {
// 模板方法
public final void generate() {
prepareData();
formatReport();
if (needHook()) {
hookMethod();
}
}
abstract void formatReport();
protected void prepareData() {
// 公共实现
}
protected boolean needHook() { return false; }
protected void hookMethod() {}
}
class PDFReportGenerator extends ReportGenerator {
@Override
void formatReport() { /* PDF格式实现 */ }
@Override
protected boolean needHook() { return true; }
}
4.3 避免继承滥用的技巧
- 使用final禁止继承：
final class UtilityClass {} - 优先用private+组合代替protected字段
- 遵循里氏替换原则：子类不应该破坏父类的行为约定
- 接口隔离原则：细粒度接口比庞大父类更灵活
我在实际项目中总结的检查清单：
- [ ] 是否真的符合is-a关系？
- [ ] 父类是否足够稳定？
- [ ] 继承层次是否超过3层？
- [ ] 是否会带来不必要的耦合？
5. 常见问题排查与性能优化
5.1 典型问题排查案例
问题现象：java.lang.ClassCastException: Parent cannot be cast to Child
分析过程：
- 检查类型转换代码：
Child c = (Child)parent; - 确认parent实际类型确实是Child实例
- 发现parent是通过反序列化得到的对象
- 最终定位：反序列化时丢失了类型信息
解决方案：
java复制// 使用getClass()进行类型检查
if (parent.getClass() == Child.class) {
Child c = (Child)parent;
}
5.2 继承相关的性能考量
-
方法调用开销：
- 普通方法调用：约5ns
- 接口方法调用：约15ns
- 虚方法调用：约10ns
-
内存占用优化技巧：
- 减少继承层次（每层继承会增加对象头开销）
- 将不常用的字段移到单独对象中（按需加载）
- 使用基本类型替代包装类
-
JIT优化机会：
- 对final方法的调用会被静态绑定
- 频繁调用的虚方法可能被去虚拟化
5.3 设计模式中的继承应用
- 装饰器模式：
java复制class BufferedReader extends Reader {
private Reader in; // 组合+继承的典型应用
BufferedReader(Reader in) {
this.in = in;
}
}
- 工厂方法模式：
java复制abstract class LoggerFactory {
public abstract Logger createLogger();
public void writeLog() {
Logger logger = createLogger();
logger.write();
}
}
class FileLoggerFactory extends LoggerFactory {
@Override
public Logger createLogger() {
return new FileLogger();
}
}
在项目实践中，我发现合理使用继承可以将代码重复率降低40%以上，但过度使用也会使系统变得僵化。关键是要在灵活性和复用性之间找到平衡点。