设计模式 4 易混淆辨析#

开发与面试经常分不清几组外观相似的模式，核心区分方式：看设计目标、接口是否变化、意图，附带代码特征对比。

1. 装饰器 vs 适配器 vs 代理#

三者都采用「包装对象」的形式，最容易混淆。

核心结论#

装饰器：接口不变，增强功能
适配器：转换接口，兼容异构
代理：控制访问，管控原始对象

装饰器（Decorator）#

目标：动态叠加功能，原始接口保持不变
包装类与被包装类实现同一个接口，可以多层嵌套拓展。

1
interface Coffee{
2
    double cost();
3
}
4
class SimpleCoffee implements Coffee{
5
    @Override public double cost(){return 10;}
6
}
7
// 装饰器，实现相同接口
8
class MilkDecorator implements Coffee{
9
    private Coffee coffee;
10
    public MilkDecorator(Coffee coffee){this.coffee = coffee;}
11
    @Override
12
    public double cost(){
13
        return coffee.cost() + 3;
14
    }
15
}

适配器（Adapter）#

目标：接口转换，解决两个类接口不兼容
新旧接口不一样，做翻译层，不侧重增强功能。

1
// 新系统标准接口
2
interface Target {void handle();}
3
// 老系统类，方法名不一致
4
class OldService {void oldHandle(){}}
5
// 适配器做转换
6
class ServiceAdapter implements Target{
7
    private OldService oldService;
8
    @Override
9
    public void handle() {
10
        oldService.oldHandle();
11
    }
12
}

代理（Proxy）#

目标：控制对真实对象的访问，增加预处理/后置处理
接口和真实对象保持一致，重点是访问管控（权限、延迟加载、AOP）。

1
interface UserService{
2
    void query();
3
}
4
class UserServiceImpl implements UserService{}
5
// 代理类
6
class UserProxy implements UserService{
7
    private UserService target;
8
    @Override
9
    public void query() {
10
        System.out.println("前置校验");
11
        target.query();
12
    }
13
}

快速区分口诀：

同接口、叠加功能 → 装饰器
接口不一样、做兼容转换 → 适配器
同接口、管控对象访问 → 代理

2. 工厂 vs 建造者#

共同点：都负责对象创建；区别在于对象复杂度与创建方式

工厂模式（工厂方法/抽象工厂）#

关注点：整体产出完整对象，不需要关心构建步骤。
适用：产品结构简单，一次性创建完成。

建造者（Builder）#

关注点：分步构造复杂对象，对象属性繁多、构造流程复杂。
适用：对象存在大量可选参数，构造步骤固定，但细节可变。

1
// Builder示例
2
class Person {
3
    private String name;
4
    private Integer age;
5
    // 私有构造
6
    private Person(Builder builder){
7
        this.name = builder.name;
8
        this.age = builder.age;
9
    }
10
    public static class Builder{
11
        private String name;
12
        private Integer age;
13
        public Builder name(String name){
14
            this.name = name;
15
            return this;
16
        }
17
        public Builder age(Integer age){
18
            this.age = age;
19
            return this;
20
        }
21
        public Person build(){
22
            return new Person(this);
23
        }
24
    }
25
}
26
// 使用：分步赋值
27
Person p = new Person.Builder().name("test").age(20).build();

区分要点：

一次性生成产品 → 工厂
分步骤组装、参数众多 → 建造者

3. 策略 vs 状态#

结构高度相似，都有上下文Context、多个实现类，是面试重难点。

策略模式#

算法之间互相独立，主动切换
上下文主动传入/设置策略；策略之间互不感知
示例：支付方式、折扣算法

1
interface PayStrategy{
2
    void pay();
3
}
4
class AliPay implements PayStrategy{}
5
class PayContext{
6
    private PayStrategy strategy;
7
    public void setStrategy(PayStrategy s){this.strategy = s;}
8
}

状态模式#

状态自动流转，状态之间具备关联性
对象内部状态发生变化，自动切换行为；状态类可以驱动状态变更
示例：订单状态（待支付→已支付→已取消）

1
// 状态接口
2
interface OrderState {
3
    void pay(OrderContext order);
4
    void cancel(OrderContext order);
5
}
6

7
// 待支付状态
8
class WaitingPayState implements OrderState {
9
    public void pay(OrderContext order) {
10
        // 支付成功，切换到已支付状态
11
        order.setState(new PaidState());
12
    }
13
    public void cancel(OrderContext order) {
14
        order.setState(new CanceledState());
15
    }
16
}
17

18
// 订单上下文
19
class OrderContext {
20
    private OrderState state;
21
    public void setState(OrderState state) {
22
        this.state = state; // 状态自动流转切换
23
    }
24
}

区分要点：

人为主动选择不同算法，算法无关联 → 策略
对象自身状态自动流转，状态之间存在切换逻辑 → 状态

总结一览#

分组	核心区分点
装饰器/适配器/代理	功能增强 / 接口转换 / 访问控制
工厂/建造者	一次性创建对象 / 分步组装复杂对象
策略/状态	主动选择独立算法 / 对象内部自动流转状态