返回专栏
· 16 分钟阅读

组合与继承


一、组合与继承的基本概念

组合(Composition)和继承(Inheritance)都可以实现代码复用,但它们表达的设计关系不同。

  • 继承: 通过建立父类与子类的类型关系,复用父类的属性和方法。
  • 组合: 通过一个对象持有其他对象的引用,将多个对象的能力组合成更复杂的功能。

二者最核心的区别是:

维度 继承 组合
核心关系 is-a(是一种) has-a(拥有一个)
代码复用 继承父类实现 委托给内部对象
类型关系 建立子类型关系 不必建立类型关系
耦合程度 通常较高 通常较低
扩展方式 扩展或重写父类 替换、增加内部组件
灵活性 受继承层次约束 可在运行时组合不同实现
多态来源 子类型多态 接口多态、委托等
主要风险 继承层次复杂、父类脆弱 对象协作和依赖管理复杂

需要注意:组合不等于简单地在一个类中声明另一个类的字段。真正有意义的组合通常包含明确的职责划分,以及对象之间的协作或委托关系。

二、继承机制

2.1 继承的基本结构

继承允许子类获得父类定义的可继承成员,并在此基础上增加或修改行为。

以 Java 为例:

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " is barking");
    }
}

使用:

Dog dog = new Dog("Buddy");

dog.eat();
dog.bark();

Dog 继承了 Animal 的可访问成员,同时增加了自己的行为。

从类型关系上看:

Animal animal = new Dog("Buddy");
animal.eat();

Dog 是 Animal 的子类型,因此可以在要求 Animal 的位置使用 Dog 对象。

2.2 继承的工作机制

继承不仅是代码复用机制,也影响类型系统、方法分派和对象初始化。

以 Java 为例,其基本结构可以抽象为:

flowchart TB
    A["定义父类 Animal"] --> B["定义子类 Dog"]
    B --> C["建立 extends 继承关系"]
    C --> D["子类获得可继承成员"]
    D --> E["子类增加或重写方法"]
    E --> F["创建子类对象"]
    F --> G["执行父类构造过程"]
    G --> H["执行子类构造过程"]
    H --> I["对象可以通过父类类型引用"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要区分三个概念:

  1. 成员继承: 子类可以使用父类中允许继承和访问的成员。
  2. 子类型关系: 子类对象可以在父类类型所要求的上下文中使用。
  3. 方法重写: 子类为继承的方法提供自己的实现,运行时可能根据实际对象类型进行动态分派。

这三个概念相互关联,但并不完全等价。

2.3 方法重写与动态分派

继承常与运行时多态结合使用。

class Animal {
    public void makeSound() {
        System.out.println("Unknown sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

调用:

Animal animal = new Dog();
animal.makeSound();

输出:

Woof

这里:

  • 引用的声明类型是 Animal。
  • 对象的实际类型是 Dog。
  • 调用可重写的实例方法时,Java 根据实际对象类型选择实现。

这种机制称为动态方法分派(Dynamic Method Dispatch)。

需要注意,Java 的静态方法、字段访问和构造方法不遵循普通实例方法的动态分派规则。方法是否能够重写,也受到 private、static、final 等修饰符限制。

2.4 继承的主要问题

继承能够减少重复代码,但也可能引入较强的结构耦合。

问题一:父类修改影响子类

父类的内部实现一旦发生变化,可能影响多个子类。

例如,父类修改了一个被子类依赖的方法的行为,原本正常工作的子类可能出现异常。

问题二:继承层次不断膨胀

当系统不断增加业务差异时,容易出现大量专门化子类:

Animal
├── FlyingAnimal
│   ├── FlyingBird
│   └── FlyingInsect
└── SwimmingAnimal
    ├── SwimmingFish
    └── SwimmingMammal

如果一个对象同时具备飞行、游泳等多个能力,单一继承体系就难以自然表达。

问题三:子类受到父类设计约束

子类需要遵守父类定义的行为契约。如果父类的设计不合理,子类可能被迫继承不需要的行为,或者通过重写规避父类的默认实现。

问题四:继承关系可能违反里氏替换原则

里氏替换原则(Liskov Substitution Principle,LSP)要求:子类型对象应该能够替换父类型对象,而不破坏程序原有的正确性。

例如:

class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int area() {
        return width * height;
    }
}

如果 Square 继承 Rectangle,并且为了保证正方形边长相等而重写两个 setter:

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;
    }

    @Override
    public void setHeight(int height) {
        this.width = height;
        this.height = height;
    }
}

调用方可能假设宽度和高度能够独立修改:

Rectangle rectangle = new Square();

rectangle.setWidth(5);
rectangle.setHeight(10);

System.out.println(rectangle.area());

调用方按照矩形的行为预期,可能认为面积应该为 50,但实际结果为 100。

问题不在于正方形的数学定义,而在于子类改变了父类原有的行为契约。

这说明:数学上的特殊关系,不一定适合直接转化为软件设计中的继承关系。

三、组合机制

3.1 组合的基本结构

组合通过对象持有其他对象,将不同职责组织在一起。

例如,一个汽车对象可以包含发动机对象:

class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

class Car {
    private final Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
        System.out.println("Car started");
    }
}

使用:

Engine engine = new Engine();
Car car = new Car(engine);

car.start();

这里:

  • Engine 负责发动机相关行为。
  • Car 负责汽车整体行为。
  • Car 通过持有 Engine 对象来使用发动机能力。

Car 并不是一种 Engine,而是拥有一个 Engine。

3.2 委托机制(Delegation)

组合通常通过委托实现行为复用。

委托是指一个对象将某项具体工作交给另一个对象完成。

例如:

interface PaymentProcessor {
    void pay(double amount);
}

class AlipayProcessor implements PaymentProcessor {
    @Override
    public void pay(double amount) {
        System.out.println("Alipay: " + amount);
    }
}

class WechatProcessor implements PaymentProcessor {
    @Override
    public void pay(double amount) {
        System.out.println("Wechat Pay: " + amount);
    }
}

class OrderService {
    private final PaymentProcessor paymentProcessor;

    public OrderService(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public void checkout(double amount) {
        paymentProcessor.pay(amount);
    }
}

使用:

PaymentProcessor processor = new AlipayProcessor();

OrderService orderService = new OrderService(processor);
orderService.checkout(100);

OrderService 不需要知道支付的具体实现,只依赖 PaymentProcessor 抽象。

如果需要切换支付方式,可以注入其他实现:

PaymentProcessor processor = new WechatProcessor();

OrderService orderService = new OrderService(processor);
orderService.checkout(100);

这体现了组合的一个重要优势:业务对象可以依赖抽象,而不是绑定某个具体实现。

3.3 组合的执行流程

flowchart TB
    A["定义能力接口"] --> B["实现不同组件"]
    B --> C["创建业务对象"]
    C --> D["注入组件依赖"]
    D --> E["业务对象接收请求"]
    E --> F["调用组件接口"]
    F --> G["组件执行具体行为"]
    G --> H["返回执行结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

3.4 组合与依赖注入

组合常常与依赖注入(Dependency Injection,DI)配合使用。

依赖注入的核心思想是:对象不负责创建所有依赖,而是由外部提供它需要的依赖对象。

常见注入方式:

注入方式 说明 特点
构造器注入 通过构造方法传入依赖 依赖明确,便于保证对象完整性
Setter 注入 通过 Setter 方法设置依赖 适合可选或可变依赖
字段注入 直接注入对象字段 代码简洁,但依赖关系不够显式
方法参数注入 调用方法时传入依赖 适合只在单次操作中使用的依赖

构造器注入示例:

class NotificationService {
    private final MessageSender sender;

    public NotificationService(MessageSender sender) {
        this.sender = sender;
    }
}

它能够明确表达对象创建所需的依赖,并且配合 final 字段,可以在构造完成后保持依赖引用不变。

但需要注意:

  • 组合不要求必须使用依赖注入框架。
  • 依赖注入是一种提供依赖的技术手段,不等于组合本身。
  • Spring 等框架可以管理对象创建、依赖注入和生命周期,但这些能力并不是组合机制成立的前提。

四、组合与继承的核心区别

4.1 is-a 与 has-a

这是区分继承和组合最常用的方式。

继承表达:

Dog is an Animal

组合表达:

Car has an Engine

但是,不能仅凭自然语言中的“是一个”就判断是否应该使用继承。

软件设计还需要考虑:

  • 子类型是否满足父类型的行为契约。
  • 父类是否提供稳定且合理的抽象。
  • 子类是否真正需要父类的行为和约束。
  • 是否存在更清晰的职责组合方式。

4.2 编译期关系与运行时灵活性

继承关系通常在类型定义时确定。

class Dog extends Animal {
}

Dog 与 Animal 的继承关系由类型声明确定。

组合关系则可以通过依赖对象的创建和注入方式进行配置。

class OrderService {
    private final PaymentProcessor processor;

    public OrderService(PaymentProcessor processor) {
        this.processor = processor;
    }
}

不同实例可以持有不同的 PaymentProcessor 实现。

因此,组合更容易支持运行时策略替换和依赖配置。

不过,继承并不意味着所有行为都只能在编译期确定。继承体系中的虚方法同样可以支持运行时多态。

4.3 复用实现与复用抽象

继承通常同时复用父类实现和类型关系。

组合可以只复用某个对象提供的能力,而不需要继承其类型。

例如:

class Logger {
    public void log(String message) {
        System.out.println(message);
    }
}

class UserService {
    private final Logger logger;

    public UserService(Logger logger) {
        this.logger = logger;
    }

    public void createUser() {
        logger.log("User created");
    }
}

UserService 使用 Logger 的功能,但并不是 Logger 的一种。

这种设计可以避免将不相关的类型强行放进同一个继承体系。

五、组合优于继承原则

5.1 原则的含义

“优先使用组合而不是继承”(Favor Composition over Inheritance)是面向对象设计中的一条重要经验原则。

它并不是要求完全放弃继承,而是强调:

当继承不是表达真实子类型关系的必要条件时,优先考虑通过组合实现代码复用和行为扩展。

原因主要有以下几点:

  1. 降低耦合: 业务对象不必依赖父类的内部实现。
  2. 职责清晰: 不同组件负责不同的功能。
  3. 扩展灵活: 可以替换组件,而不必不断增加子类。
  4. 更容易测试: 可以注入模拟对象或测试替身。
  5. 避免继承层次膨胀: 多种能力可以独立组合。

5.2 继承导致的类数量膨胀

假设一个系统需要表示不同类型的角色:

  • 管理员
  • 普通用户
  • 访客

每种角色又有不同能力:

  • 登录
  • 支付
  • 导出数据
  • 管理用户

如果使用继承不断组合角色和能力,很容易出现大量子类。

例如:

User
├── AdminUser
├── GuestUser
├── PayingUser
├── ExportingUser
├── AdminPayingUser
└── AdminExportingUser

随着角色和能力增加,类的数量和继承层次会变得难以维护。

使用组合,可以将角色与能力拆分:

interface Permission {
    void execute();
}

class PaymentPermission implements Permission {
    @Override
    public void execute() {
        System.out.println("Payment allowed");
    }
}

class ExportPermission implements Permission {
    @Override
    public void execute() {
        System.out.println("Export allowed");
    }
}

class User {
    private final List<Permission> permissions;

    public User(List<Permission> permissions) {
        this.permissions = permissions;
    }

    public void executePermissions() {
        for (Permission permission : permissions) {
            permission.execute();
        }
    }
}

不同用户可以持有不同的权限组件。

这种设计将用户身份和权限能力分离,避免为了不同能力组合创建大量子类。

5.3 策略模式:组合的典型应用

策略模式(Strategy Pattern)是组合思想的典型应用。

它将可变化的算法封装为独立策略,使使用者可以在不同策略之间切换。