本文围绕“Java 继承怎么用？从概念到实战的超详细代码示例，一篇文章搞定继承”这一主题展开，面向开发者从理论到实践搭建完整的继承方案。
Java 继承的基础概念与语法
继承的核心思想与 extends 关键字
在 Java 中，继承是一种实现代码复用和行为扩展的机制，允许子类继承父类的字段与方法，从而实现“复用与扩展”的组合。通过关键字extends，子类可以获得父类的实现，并在需要时覆盖（override）父类的方法以实现多态行为。代码复用和行为扩展是使用继承最直观的收益。
需要注意的是，Java 采用单继承模型，也就是说一个类只能直接继承一个父类，但可以实现任意数量的接口以获得额外行为。这一设计让继承关系树保持清晰，同时通过接口提供了多态的灵活性。
示例代码帮助你把概念落地：
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void speak() {
System.out.println(name + " 发出声音");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void speak() {
System.out.println(name + " 汪汪叫");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog("小黄");
d.speak(); // 输出：小黄 汪汪叫
}
}
从上面的代码中可以看到，子类通过 extends 继承父类的字段与方法，并通过 @Override 注解实现对父类方法的覆盖，以实现多态的行为。
构造器与 super 的使用
除了字段和方法，构造器也是继承关系中的重要一环。子类构造器在初始化时通常需要先调用父类的构造器，这个过程称为构造器链，通过显式的 super() 调用实现参数传递与父类字段初始化。
在子类构造器的第一行必须是对 super(...) 的调用（若不显式调用，Java 会调用父类的无参构造器）。通过 super，你可以控制父类字段的初始值，从而确保对象在生命周期早期就处于合法状态。
以下示例演示了带参父构造器和子构造器的使用：
public class Vehicle {
protected String model;
public Vehicle(String model) {
this.model = model;
}
}
public class Car extends Vehicle {
private int year;
public Car(String model, int year) {
super(model); // 调用父类构造器
this.year = year;
}
@Override
public String toString() {
return year + "年 " + model;
}
}
通过 super(...)，父类的字段得到正确初始化，子类还能在此基础上扩展自己的字段，确保对象在实例化阶段即具备完整的状态。
实战演练：从简单到复杂的继承示例
多态与方法覆盖的演示
继承的强大之处在于多态能力：父类引用指向子类对象，运行时会调用子类的覆盖方法。这使得调用方无需关心具体实现，只需通过父类型进行操作，即实现了“对类型的解耦”。
下面的示例包含一个基类 Shape 和两个派生类 Circle、Rectangle，它们都覆盖了 draw() 方法，演示多态在实际场景中的效果：
public abstract class Shape {
protected String color;
public Shape(String color) {
this.color = color;
}
public abstract void draw();
}
public class Circle extends Shape {
private double radius;
public Circle(String color, double radius) {
super(color);
this.radius = radius;
}
@Override
public void draw() {
System.out.println("绘制圆形，颜色：" + color + "，半径：" + radius);
}
}
public class Rectangle extends Shape {
private double width, height;
public Rectangle(String color, double width, double height) {
super(color);
this.width = width;
this.height = height;
}
@Override
public void draw() {
System.out.println("绘制矩形，颜色：" + color + "，宽：" + width + "，高：" + height);
}
}
class Canvas {
public static void main(String[] args) {
Shape s1 = new Circle("red", 5.0);
Shape s2 = new Rectangle("blue", 4.0, 3.0);
s1.draw(); // Circle 的实现
s2.draw(); // Rectangle 的实现
}
}
多态行为在运行时绑定具体的子类实现，使得同一段代码可以处理不同的对象类型，极大提升了代码的扩展性与可维护性。
抽象类与接口的协同
在复杂系统中，通常会同时使用抽象类和接口来组织继承结构。抽象类可以提供部分实现和公共字段，而接口则定义契约（方法签名），让各个实现类按照统一接口进行协作。
下面的示例展示了抽象类与接口的协同：
public interface Pet {
String getName();
void play();
}
public abstract class Animal implements Pet {
protected String name;
public Animal(String name) { this.name = name; }
@Override public String getName() { return name; }
// 子类需实现 play()
}
public class Dog extends Animal {
public Dog(String name) { super(name); }
@Override public void play() {
System.out.println(name + " 在玩球");
}
}
通过这样的设计，抽象类提供共享实现，而接口提供灵活的契约，帮助系统实现高度可组合的组件。
设计原则与实践要点
何时使用继承，何时用组合
在软件设计中，继承并非万能工具。遵循里氏替换原则（Liskov Substitution Principle）即可确保子类对象能无缝替换父类对象而不破坏程序行为。
通用规则是：如果“行为是父类本质上的扩展或替代”，并且“子类与父类存在天然的“是一个”关系”，可以考虑使用继承；否则应考虑组合优先于继承，通过将所需功能作为成员对象来实现复用。
以下示例对比说明了两种思路：
// 继承示例
public class Employee extends Person {
private String department;
// 继承带来字段与行为的直接复用
}
// 组合示例
public class EmailService {
public void send(String to, String subject, String body) { /* 发送实现 */ }
}
public class UserNotifier {
private EmailService emailService; // 组合
public UserNotifier(EmailService es) { this.emailService = es; }
public void notify(String user, String msg) {
emailService.send(user, "通知", msg);
}
}
组合优先的思想有助于降低耦合、提高可测试性和灵活性，但在需要显式的“是一个”关系时，继承是更自然的选择。
避免常见坑点与性能考虑
在设计继承结构时，需注意以下要点：不要暴露父类实现细节，应通过封装和受保护的接口进行访问；避免过度覆盖，过度的覆盖会导致维护成本上升；谨慎使用 final，用于阻止子类覆盖的方法可以带来稳定性，但也要避免过于僵化的设计。
此外，构造器链与对象创建成本也需要关注，若继承层级过深，可能影响性能与调试难度。通过合适的设计分层、使用接口与组合，可以在保留继承带来的便利的同时，降低系统的耦合度。
下面的代码展示了一个包含 final 方法的父类与子类无法覆盖该方法的情况，帮助理解
public class Base {
public final void fixedBehavior() {
// 不可覆盖的行为实现
System.out.println("基类固定行为");
}
}
public class Derived extends Base {
// 编译错误：无法覆盖 final 方法 fixedBehavior
// public void fixedBehavior() { }
}
