策略模式Strategy-Pattern与状态模式State-Pattern的异同
目录
策略模式（Strategy Pattern）与状态模式（State Pattern）的异同
相同点
行为委托
两者均通过将行为委托给其他对象来实现功能解耦，遵循“组合优于继承”的原则。
- 策略模式 ：将算法逻辑委托给具体的策略类。
- 状态模式 ：将状态相关的行为委托给具体的状态类。
类结构相似
两者在类图结构上高度相似，均包含：
- 上下文类（Context） ：持有策略或状态对象的引用。
- 抽象接口（Strategy/State） ：定义行为方法的统一接口。
- 具体实现类（ConcreteStrategy/ConcreteState） ：实现具体行为。
开闭原则
均支持扩展新的策略或状态，无需修改现有代码。
不同点
| 维度 | 策略模式 | 状态模式 |
|---|---|---|
| 核心目的 | 灵活替换算法 | 管理对象的状态转换 |
| 控制权 | 客户端主动选择策略 | 状态对象自动触发状态转换 |
| 依赖关系 | 策略之间相互独立 | 状态之间可能相互依赖 |
| 生命周期 | 策略的生命周期由客户端管理 | 状态的转换由上下文或状态自身管理 |
| 典型场景 | 算法选择（排序、支付方式） | 对象状态管理（订单、游戏角色状态） |
| 代码复杂度 | 简单，仅需替换策略 | 复杂，需处理状态转换逻辑 |
应用场景示例
策略模式：支付方式选择
// 抽象策略接口
class PaymentStrategy {
public:
virtual void pay(int amount) = 0;
};
// 具体策略类：信用卡支付
class CreditCardPayment : public PaymentStrategy {
public:
void pay(int amount) override {
std::cout << "Paid " << amount << " via Credit Card." << std::endl;
}
};
// 具体策略类：支付宝支付
class AlipayPayment : public PaymentStrategy {
public:
void pay(int amount) override {
std::cout << "Paid " << amount << " via Alipay." << std::endl;
}
};
// 上下文类（订单）
class Order {
private:
PaymentStrategy* strategy;
public:
void setStrategy(PaymentStrategy* strategy) {
this->strategy = strategy;
}
void checkout(int amount) {
strategy->pay(amount);
}
};
// 使用示例
int main() {
Order order;
CreditCardPayment creditCard;
AlipayPayment alipay;
order.setStrategy(&creditCard);
order.checkout(100); // 输出: Paid 100 via Credit Card.
order.setStrategy(&alipay);
order.checkout(200); // 输出: Paid 200 via Alipay.
}状态模式：订单状态管理
// 抽象状态接口
class OrderState {
public:
virtual void handle(OrderContext* context) = 0;
};
// 具体状态类：待付款
class PendingPaymentState : public OrderState {
public:
void handle(OrderContext* context) override {
std::cout << "Processing payment..." << std::endl;
context->setState(new PaidState()); // 状态转换
}
};
// 具体状态类：已付款
class PaidState : public OrderState {
public:
void handle(OrderContext* context) override {
std::cout << "Order is paid. Preparing for shipment." << std::endl;
context->setState(new ShippedState());
}
};
// 上下文类（订单）
class OrderContext {
private:
OrderState* state;
public:
OrderContext() : state(new PendingPaymentState()) {}
void setState(OrderState* newState) {
delete state;
state = newState;
}
void proceed() {
state->handle(this);
}
};
// 使用示例
int main() {
OrderContext order;
order.proceed(); // 输出: Processing payment... → 状态变为 PaidState
order.proceed(); // 输出: Order is paid. Preparing for shipment. → 状态变为 ShippedState
}总结
- 策略模式 ：关注 算法的灵活替换 ，由客户端主动控制策略的选择。
- 状态模式 ：关注 对象内部状态的动态转换 ，状态变化由上下文或状态自身触发。
两者在结构上相似，但设计目标和适用场景不同。 策略模式是“静态多态”，而状态模式是“动态多态” 。