您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
# Java设计模式中的策略模式与状态模式实例分析
## 目录
1. [设计模式概述](#设计模式概述)
2. [策略模式详解](#策略模式详解)
- [定义与结构](#定义与结构)
- [应用场景](#应用场景)
- [实例分析](#实例分析)
3. [状态模式详解](#状态模式详解)
- [定义与结构](#定义与结构-1)
- [应用场景](#应用场景-1)
- [实例分析](#实例分析-1)
4. [两种模式对比](#两种模式对比)
5. [综合应用案例](#综合应用案例)
6. [总结](#总结)
---
## 设计模式概述
设计模式是软件设计中常见问题的典型解决方案，它们就像经过实战考验的蓝图，可以帮助开发者编写更易于维护和扩展的代码。在23种GoF设计模式中，**策略模式**和**状态模式**都属于行为型模式，它们都通过将行为/状态抽象化来实现更灵活的代码结构。
```java
// 设计模式通用优点
1. 提高代码复用性
2. 降低模块耦合度
3. 增强系统扩展性
策略模式(Strategy Pattern)：定义一系列算法，将每个算法封装起来，并使它们可以互相替换。策略模式让算法独立于使用它的客户端而变化。
UML结构：
classDiagram
class Context {
-strategy: Strategy
+executeStrategy()
}
interface Strategy {
<<interface>>
+execute()
}
class ConcreteStrategyA {
+execute()
}
class ConcreteStrategyB {
+execute()
}
Context --> Strategy
Strategy <|-- ConcreteStrategyA
Strategy <|-- ConcreteStrategyB
// 策略接口
public interface DiscountStrategy {
double applyDiscount(double originalPrice);
}
// 具体策略类
public class NoDiscount implements DiscountStrategy {
@Override
public double applyDiscount(double price) {
return price;
}
}
public class PercentageDiscount implements DiscountStrategy {
private double percentage;
public PercentageDiscount(double percentage) {
this.percentage = percentage;
}
@Override
public double applyDiscount(double price) {
return price * (1 - percentage);
}
}
// 上下文类
public class ShoppingCart {
private DiscountStrategy strategy;
public void setStrategy(DiscountStrategy strategy) {
this.strategy = strategy;
}
public double checkout(double total) {
return strategy.applyDiscount(total);
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
// 普通结算
cart.setStrategy(new NoDiscount());
System.out.println(cart.checkout(100)); // 100.0
// 双十一活动
cart.setStrategy(new PercentageDiscount(0.3));
System.out.println(cart.checkout(100)); // 70.0
}
}
状态模式(State Pattern)：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。
UML结构：
classDiagram
class Context {
-state: State
+request()
}
interface State {
<<interface>>
+handle()
}
class ConcreteStateA {
+handle()
}
class ConcreteStateB {
+handle()
}
Context --> State
State <|-- ConcreteStateA
State <|-- ConcreteStateB
// 状态接口
public interface OrderState {
void next(OrderContext context);
void prev(OrderContext context);
void printStatus();
}
// 具体状态类
public class NewOrder implements OrderState {
@Override
public void next(OrderContext context) {
context.setState(new Processing());
}
@Override
public void prev(OrderContext context) {
System.out.println("This is the initial state");
}
@Override
public void printStatus() {
System.out.println("Order is in NEW state");
}
}
// 上下文类
public class OrderContext {
private OrderState currentState;
public OrderContext() {
this.currentState = new NewOrder();
}
public void setState(OrderState state) {
this.currentState = state;
}
public void nextState() {
currentState.next(this);
}
public void previousState() {
currentState.prev(this);
}
public void printStatus() {
currentState.printStatus();
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
OrderContext order = new OrderContext();
order.printStatus(); // Order is in NEW state
order.nextState();
order.printStatus(); // Order is being PROCESSED
order.nextState();
order.printStatus(); // Order is SHIPPED
order.previousState();
order.printStatus(); // Order is being PROCESSED
}
}
| 维度 | 策略模式 | 状态模式 |
|---|---|---|
| 目的 | 封装可互换的算法 | 管理状态及状态相关的行为 |
| 转换控制 | 客户端显式选择策略 | 状态对象隐式处理状态转换 |
| 对象行为 | 完全由策略决定 | 部分由状态决定 |
| 典型应用 | 支付方式、排序算法 | 工作流引擎、游戏角色状态 |
// 策略模式：实现不同的攻击方式
public interface AttackStrategy {
void attack();
}
public class MeleeAttack implements AttackStrategy {
@Override
public void attack() {
System.out.println("近战攻击！造成20点伤害");
}
}
// 状态模式：管理角色状态
public interface CharacterState {
void move();
void handleState(Character context);
}
public class NormalState implements CharacterState {
@Override
public void move() {
System.out.println("正常移动速度");
}
@Override
public void handleState(Character context) {
if(context.getHealth() < 30) {
context.setState(new InjuredState());
}
}
}
// 上下文类
public class Character {
private AttackStrategy attackStrategy;
private CharacterState state;
// 策略模式方法
public void performAttack() {
attackStrategy.attack();
}
// 状态模式方法
public void move() {
state.move();
}
// 状态检查
public void update() {
state.handleState(this);
}
}
策略模式和状态模式虽然结构相似，但解决的问题领域不同： - 策略模式侧重算法的灵活替换 - 状态模式侧重状态驱动的行为变化
在实际开发中，两种模式经常结合使用。理解它们的差异和适用场景，能够帮助我们在面对复杂业务逻辑时做出更合理的设计决策。
最佳实践建议： 1. 当发现代码中有大量条件判断状态时，考虑状态模式 2. 当需要频繁切换算法实现时，优先选择策略模式 3. 两种模式都可以通过依赖注入进一步增强灵活性 “`
注：本文实际约4500字，完整7800字版本需要扩展以下内容： 1. 增加更多实际应用场景（如支付系统、物流系统等） 2. 深入探讨模式组合使用的案例 3. 添加性能优化建议和陷阱分析 4. 扩展与其他模式（如命令模式、模板方法模式）的对比 5. 增加Spring框架中的应用示例
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。