一、组合与继承的基本概念
组合(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
需要区分三个概念:
- 成员继承: 子类可以使用父类中允许继承和访问的成员。
- 子类型关系: 子类对象可以在父类类型所要求的上下文中使用。
- 方法重写: 子类为继承的方法提供自己的实现,运行时可能根据实际对象类型进行动态分派。
这三个概念相互关联,但并不完全等价。
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)是面向对象设计中的一条重要经验原则。
它并不是要求完全放弃继承,而是强调:
当继承不是表达真实子类型关系的必要条件时,优先考虑通过组合实现代码复用和行为扩展。
原因主要有以下几点:
- 降低耦合: 业务对象不必依赖父类的内部实现。
- 职责清晰: 不同组件负责不同的功能。
- 扩展灵活: 可以替换组件,而不必不断增加子类。
- 更容易测试: 可以注入模拟对象或测试替身。
- 避免继承层次膨胀: 多种能力可以独立组合。
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)是组合思想的典型应用。
它将可变化的算法封装为独立策略,使使用者可以在不同策略之间切换。