当前位置： 首页 > news >正文

行为型设计模式：对象协作的舞蹈家（中）

news 2025/8/17 14:52:39

🚪 传送门：🕺 行为型设计模式：对象协作的舞蹈家（上）

🔄 第四部分：状态模式（State Pattern）

🔄 状态舞者的登场 🔄
┌─────────────────────────────────────┐
│  🔄 状态者：我是状态变化艺术家！    │
│                                     │
│  🎮 角色："我现在是正常状态！"      │
│  🔄 状态者："我来改变行为！"        │
│  🎮 角色："我现在是受伤状态！"      │
│  🔄 状态者："继续改变行为！"        │
│                                     │
│  💡 核心思想：状态影响行为          │
└─────────────────────────────────────┘

🏗️ 状态模式UML类图

uses
uses
implements
implements
references
references
«interface»
State
+handle()
ConcreteStateA
-context: Context
+handle()
ConcreteStateB
-context: Context
+handle()
Context
-state: State
+setState(state)
+request()
Client
+useState()

⏱️ 状态模式时序图

客户端上下文状态A状态Brequest()handle()setState(StateB)request()handle()setState(StateA)客户端上下文状态A状态B

4.1 🎭 什么是状态模式？

一句话理解：对象的行为随着状态的改变而改变，就像游戏角色的不同状态！

定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

应用场景：状态机、游戏角色状态、订单状态、工作流状态

4.2 🛠️ 状态模式的实现

4.2.1 🏗️ 基本结构

💡 小贴士：状态模式就像游戏角色的状态变化，不同状态下有不同的行为表现！

核心组件：

  • State（状态）：状态的抽象接口
  • ConcreteState（具体状态）：具体的状态实现
  • Context（上下文）：维护当前状态的对象
4.2.2 🚀 多种实现方式
实现方式特点推荐度
状态接口通过接口定义状态行为⭐⭐⭐⭐⭐
状态枚举使用枚举简化状态管理⭐⭐⭐⭐
状态机复杂状态转换逻辑⭐⭐⭐⭐⭐

状态接口实现：

// 状态接口：通过接口定义状态行为
public interface VendingMachineState {void insertCoin();void ejectCoin();void selectProduct();void dispense();
}public class NoCoinState implements VendingMachineState {private VendingMachine vendingMachine;public NoCoinState(VendingMachine vendingMachine) {this.vendingMachine = vendingMachine;}@Overridepublic void insertCoin() {System.out.println("投币成功");vendingMachine.setState(vendingMachine.getHasCoinState());}@Overridepublic void ejectCoin() {System.out.println("没有投币，无法退币");}@Overridepublic void selectProduct() {System.out.println("请先投币");}@Overridepublic void dispense() {System.out.println("请先投币");}
}public class HasCoinState implements VendingMachineState {private VendingMachine vendingMachine;public HasCoinState(VendingMachine vendingMachine) {this.vendingMachine = vendingMachine;}@Overridepublic void insertCoin() {System.out.println("已经投币，请选择商品");}@Overridepublic void ejectCoin() {System.out.println("退币成功");vendingMachine.setState(vendingMachine.getNoCoinState());}@Overridepublic void selectProduct() {System.out.println("选择商品成功");vendingMachine.setState(vendingMachine.getSoldState());}@Overridepublic void dispense() {System.out.println("请先选择商品");}
}public class SoldState implements VendingMachineState {private VendingMachine vendingMachine;public SoldState(VendingMachine vendingMachine) {this.vendingMachine = vendingMachine;}@Overridepublic void insertCoin() {System.out.println("请等待商品出货");}@Overridepublic void ejectCoin() {System.out.println("商品已选择，无法退币");}@Overridepublic void selectProduct() {System.out.println("商品已选择，请等待出货");}@Overridepublic void dispense() {System.out.println("商品出货");vendingMachine.releaseProduct();if (vendingMachine.getCount() > 0) {vendingMachine.setState(vendingMachine.getNoCoinState());} else {vendingMachine.setState(vendingMachine.getSoldOutState());}}
}public class SoldOutState implements VendingMachineState {private VendingMachine vendingMachine;public SoldOutState(VendingMachine vendingMachine) {this.vendingMachine = vendingMachine;}@Overridepublic void insertCoin() {System.out.println("商品已售罄，无法投币");}@Overridepublic void ejectCoin() {System.out.println("没有投币，无法退币");}@Overridepublic void selectProduct() {System.out.println("商品已售罄");}@Overridepublic void dispense() {System.out.println("商品已售罄");}
}public class VendingMachine {private VendingMachineState noCoinState;private VendingMachineState hasCoinState;private VendingMachineState soldState;private VendingMachineState soldOutState;private VendingMachineState currentState;private int count = 0;public VendingMachine(int count) {noCoinState = new NoCoinState(this);hasCoinState = new HasCoinState(this);soldState = new SoldState(this);soldOutState = new SoldOutState(this);this.count = count;if (count > 0) {currentState = noCoinState;} else {currentState = soldOutState;}}public void insertCoin() {currentState.insertCoin();}public void ejectCoin() {currentState.ejectCoin();}public void selectProduct() {currentState.selectProduct();}public void dispense() {currentState.dispense();}public void setState(VendingMachineState state) {currentState = state;}public void releaseProduct() {System.out.println("商品从售货机中出来");count--;}public int getCount() {return count;}// Getter methods for statespublic VendingMachineState getNoCoinState() {return noCoinState;}public VendingMachineState getHasCoinState() {return hasCoinState;}public VendingMachineState getSoldState() {return soldState;}public VendingMachineState getSoldOutState() {return soldOutState;}
}

状态枚举实现：

// 状态枚举：使用枚举简化状态管理
public enum OrderState {PENDING {@Overridepublic void process(Order order) {System.out.println("订单待处理，开始处理...");order.setState(PROCESSING);}@Overridepublic void cancel(Order order) {System.out.println("订单取消");order.setState(CANCELLED);}@Overridepublic void ship(Order order) {System.out.println("订单还未处理，无法发货");}@Overridepublic void deliver(Order order) {System.out.println("订单还未发货，无法交付");}},PROCESSING {@Overridepublic void process(Order order) {System.out.println("订单正在处理中...");}@Overridepublic void cancel(Order order) {System.out.println("订单处理中，无法取消");}@Overridepublic void ship(Order order) {System.out.println("订单处理完成，开始发货");order.setState(SHIPPED);}@Overridepublic void deliver(Order order) {System.out.println("订单还未发货，无法交付");}},SHIPPED {@Overridepublic void process(Order order) {System.out.println("订单已发货，无法重新处理");}@Overridepublic void cancel(Order order) {System.out.println("订单已发货，无法取消");}@Overridepublic void ship(Order order) {System.out.println("订单已发货");}@Overridepublic void deliver(Order order) {System.out.println("订单交付完成");order.setState(DELIVERED);}},DELIVERED {@Overridepublic void process(Order order) {System.out.println("订单已交付，无法重新处理");}@Overridepublic void cancel(Order order) {System.out.println("订单已交付，无法取消");}@Overridepublic void ship(Order order) {System.out.println("订单已交付，无法重新发货");}@Overridepublic void deliver(Order order) {System.out.println("订单已交付");}},CANCELLED {@Overridepublic void process(Order order) {System.out.println("订单已取消，无法处理");}@Overridepublic void cancel(Order order) {System.out.println("订单已取消");}@Overridepublic void ship(Order order) {System.out.println("订单已取消，无法发货");}@Overridepublic void deliver(Order order) {System.out.println("订单已取消，无法交付");}};public abstract void process(Order order);public abstract void cancel(Order order);public abstract void ship(Order order);public abstract void deliver(Order order);
}public class Order {private String orderId;private OrderState state;public Order(String orderId) {this.orderId = orderId;this.state = OrderState.PENDING;}public void process() {state.process(this);}public void cancel() {state.cancel(this);}public void ship() {state.ship(this);}public void deliver() {state.deliver(this);}public void setState(OrderState state) {this.state = state;}public OrderState getState() {return state;}public String getOrderId() {return orderId;}
}
4.2.3 ⚙️ 状态机实现
// 状态机：复杂状态转换逻辑
public class StateMachine<T> {private T currentState;private Map<T, Map<String, T>> transitions = new HashMap<>();private Map<T, Map<String, Runnable>> actions = new HashMap<>();public StateMachine(T initialState) {this.currentState = initialState;}public void addTransition(T fromState, String event, T toState) {transitions.computeIfAbsent(fromState, k -> new HashMap<>()).put(event, toState);}public void addAction(T state, String event, Runnable action) {actions.computeIfAbsent(state, k -> new HashMap<>()).put(event, action);}public boolean fire(String event) {Map<String, T> stateTransitions = transitions.get(currentState);if (stateTransitions != null && stateTransitions.containsKey(event)) {// 执行当前状态的退出动作executeAction(currentState, "exit");// 执行事件动作executeAction(currentState, event);// 转换状态T newState = stateTransitions.get(event);currentState = newState;// 执行新状态的进入动作executeAction(currentState, "enter");return true;}return false;}private void executeAction(T state, String event) {Map<String, Runnable> stateActions = actions.get(state);if (stateActions != null) {Runnable action = stateActions.get(event);if (action != null) {action.run();}}}public T getCurrentState() {return currentState;}
}// 使用状态机的游戏角色状态管理
public enum GameState {IDLE, WALKING, RUNNING, JUMPING, ATTACKING, DEFENDING, DEAD
}public class GameCharacter {private String name;private StateMachine<GameState> stateMachine;public GameCharacter(String name) {this.name = name;this.stateMachine = new StateMachine<>(GameState.IDLE);setupStateMachine();}private void setupStateMachine() {// 定义状态转换stateMachine.addTransition(GameState.IDLE, "walk", GameState.WALKING);stateMachine.addTransition(GameState.IDLE, "run", GameState.RUNNING);stateMachine.addTransition(GameState.IDLE, "jump", GameState.JUMPING);stateMachine.addTransition(GameState.IDLE, "attack", GameState.ATTACKING);stateMachine.addTransition(GameState.IDLE, "defend", GameState.DEFENDING);stateMachine.addTransition(GameState.WALKING, "stop", GameState.IDLE);stateMachine.addTransition(GameState.WALKING, "run", GameState.RUNNING);stateMachine.addTransition(GameState.WALKING, "jump", GameState.JUMPING);stateMachine.addTransition(GameState.RUNNING, "stop", GameState.IDLE);stateMachine.addTransition(GameState.RUNNING, "walk", GameState.WALKING);stateMachine.addTransition(GameState.RUNNING, "jump", GameState.JUMPING);stateMachine.addTransition(GameState.JUMPING, "land", GameState.IDLE);stateMachine.addTransition(GameState.JUMPING, "attack", GameState.ATTACKING);stateMachine.addTransition(GameState.ATTACKING, "finish", GameState.IDLE);stateMachine.addTransition(GameState.ATTACKING, "defend", GameState.DEFENDING);stateMachine.addTransition(GameState.DEFENDING, "finish", GameState.IDLE);stateMachine.addTransition(GameState.DEFENDING, "attack", GameState.ATTACKING);// 所有状态都可以转换到死亡状态for (GameState state : GameState.values()) {if (state != GameState.DEAD) {stateMachine.addTransition(state, "die", GameState.DEAD);}}// 定义状态动作stateMachine.addAction(GameState.IDLE, "enter", () -> System.out.println(name + " 进入待机状态"));stateMachine.addAction(GameState.WALKING, "enter", () -> System.out.println(name + " 开始行走"));stateMachine.addAction(GameState.RUNNING, "enter", () -> System.out.println(name + " 开始奔跑"));stateMachine.addAction(GameState.JUMPING, "enter", () -> System.out.println(name + " 开始跳跃"));stateMachine.addAction(GameState.ATTACKING, "enter", () -> System.out.println(name + " 开始攻击"));stateMachine.addAction(GameState.DEFENDING, "enter", () -> System.out.println(name + " 开始防御"));stateMachine.addAction(GameState.DEAD, "enter", () -> System.out.println(name + " 死亡"));}public void walk() {stateMachine.fire("walk");}public void run() {stateMachine.fire("run");}public void jump() {stateMachine.fire("jump");}public void attack() {stateMachine.fire("attack");}public void defend() {stateMachine.fire("defend");}public void stop() {stateMachine.fire("stop");}public void land() {stateMachine.fire("land");}public void finish() {stateMachine.fire("finish");}public void die() {stateMachine.fire("die");}public GameState getCurrentState() {return stateMachine.getCurrentState();}
}
4.2.3 🎯 标准实现示例
// 状态接口 - 定义状态的行为
public interface State {void handle();
}// 具体状态A - 实现状态A的行为
public class ConcreteStateA implements State {private Context context;public ConcreteStateA(Context context) {this.context = context;}@Overridepublic void handle() {System.out.println("状态A的处理");context.setState(new ConcreteStateB(context));}
}// 具体状态B - 实现状态B的行为
public class ConcreteStateB implements State {private Context context;public ConcreteStateB(Context context) {this.context = context;}@Overridepublic void handle() {System.out.println("状态B的处理");context.setState(new ConcreteStateA(context));}
}// 上下文 - 维护当前状态的对象
public class Context {private State state;public Context() {state = new ConcreteStateA(this);}public void setState(State state) {this.state = state;}public void request() {state.handle();}
}
4.2.4 🎯 实际应用示例
// 售货机状态接口
public interface VendingMachineState {void insertCoin();void ejectCoin();void selectProduct();void dispense();
}// 无币状态
public class NoCoinState implements VendingMachineState {private VendingMachine vendingMachine;public NoCoinState(VendingMachine vendingMachine) {this.vendingMachine = vendingMachine;}@Overridepublic void insertCoin() {System.out.println("投币成功");vendingMachine.setState(vendingMachine.getHasCoinState());}@Overridepublic void ejectCoin() {System.out.println("没有投币，无法退币");}@Overridepublic void selectProduct() {System.out.println("请先投币");}@Overridepublic void dispense() {System.out.println("请先投币");}
}// 有币状态
public class HasCoinState implements VendingMachineState {private VendingMachine vendingMachine;public HasCoinState(VendingMachine vendingMachine) {this.vendingMachine = vendingMachine;}@Overridepublic void insertCoin() {System.out.println("已经投币，请选择商品");}@Overridepublic void ejectCoin() {System.out.println("退币成功");vendingMachine.setState(vendingMachine.getNoCoinState());}@Overridepublic void selectProduct() {System.out.println("选择商品成功");vendingMachine.setState(vendingMachine.getSoldState());}@Overridepublic void dispense() {System.out.println("请先选择商品");}
}// 自动售货机
public class VendingMachine {private VendingMachineState noCoinState;private VendingMachineState hasCoinState;private VendingMachineState soldState;private VendingMachineState currentState;public VendingMachine() {noCoinState = new NoCoinState(this);hasCoinState = new HasCoinState(this);soldState = new SoldState(this);currentState = noCoinState;}public void insertCoin() {currentState.insertCoin();}public void ejectCoin() {currentState.ejectCoin();}public void selectProduct() {currentState.selectProduct();}public void dispense() {currentState.dispense();}public void setState(VendingMachineState state) {currentState = state;}public VendingMachineState getNoCoinState() {return noCoinState;}public VendingMachineState getHasCoinState() {return hasCoinState;}public VendingMachineState getSoldState() {return soldState;}
}

📋 第五部分：模板方法模式（Template Method Pattern）

📋 模板舞者的登场 📋
┌─────────────────────────────────────┐
│  📋 模板者：我是算法框架设计师！    │
│                                     │
│  🍵 咖啡："我要冲泡咖啡！"          │
│  📋 模板者："我来定义框架！"        │
│  🍵 茶："我要冲泡茶！"              │
│  📋 模板者："继续定义框架！"        │
│                                     │
│  💡 核心思想：算法骨架固定          │
└─────────────────────────────────────┘

🏗️ 模板方法模式UML类图

uses
extends
extends
«abstract»
AbstractClass
+templateMethod()
+primitiveOperation1()
+primitiveOperation2()
+concreteOperation()
+hook()
ConcreteClassA
+primitiveOperation1()
+primitiveOperation2()
ConcreteClassB
+primitiveOperation1()
+primitiveOperation2()
+hook()
Client
+useTemplate()

⏱️ 模板方法模式时序图

客户端抽象类具体类templateMethod()primitiveOperation1()resultconcreteOperation()primitiveOperation2()resulthook()resultresult客户端抽象类具体类

5.1 🎭 什么是模板方法模式？

一句话理解：定义算法骨架，让子类实现具体步骤，就像制作饮料的模板！

定义：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

应用场景：算法框架、代码复用、钩子方法、流程控制

5.2 🛠️ 模板方法模式的实现

5.2.1 🏗️ 基本结构

💡 小贴士：模板方法模式就像烹饪菜谱，定义了步骤框架，具体实现可以灵活变化！

核心组件：

  • AbstractClass（抽象类）：定义算法框架
  • ConcreteClass（具体类）：实现具体步骤
  • Template Method（模板方法）：定义算法骨架
5.2.2 🚀 多种实现方式
实现方式特点推荐度
抽象类通过抽象类定义模板⭐⭐⭐⭐⭐
钩子方法提供默认实现的可选方法⭐⭐⭐⭐⭐
算法骨架固定算法流程，可变步骤⭐⭐⭐⭐⭐
5.2.1 🏗️ 抽象类实现
// 抽象类：通过抽象类定义模板
public abstract class DataProcessor {// 模板方法，定义算法骨架public final void process() {readData();processData();writeData();cleanup();}// 抽象方法，子类必须实现protected abstract void readData();protected abstract void processData();protected abstract void writeData();// 具体方法，所有子类共享protected void cleanup() {System.out.println("清理资源");}
}public class CSVProcessor extends DataProcessor {@Overrideprotected void readData() {System.out.println("读取CSV文件");}@Overrideprotected void processData() {System.out.println("处理CSV数据");}@Overrideprotected void writeData() {System.out.println("写入CSV文件");}
}public class JSONProcessor extends DataProcessor {@Overrideprotected void readData() {System.out.println("读取JSON文件");}@Overrideprotected void processData() {System.out.println("处理JSON数据");}@Overrideprotected void writeData() {System.out.println("写入JSON文件");}
}public class XMLProcessor extends DataProcessor {@Overrideprotected void readData() {System.out.println("读取XML文件");}@Overrideprotected void processData() {System.out.println("处理XML数据");}@Overrideprotected void writeData() {System.out.println("写入XML文件");}
}
5.2.2 🎣 钩子方法实现
// 钩子方法：提供默认实现的可选方法
public abstract class BeverageWithHooks {// 模板方法public final void prepareBeverage() {boilWater();brew();pourInCup();if (customerWantsCondiments()) {addCondiments();}if (customerWantsIce()) {addIce();}if (customerWantsSugar()) {addSugar();}}// 抽象方法protected abstract void brew();protected abstract void addCondiments();// 具体方法protected void boilWater() {System.out.println("烧开水");}protected void pourInCup() {System.out.println("倒入杯中");}// 钩子方法 - 默认实现protected boolean customerWantsCondiments() {return true; // 默认需要调味品}protected boolean customerWantsIce() {return false; // 默认不需要冰}protected boolean customerWantsSugar() {return true; // 默认需要糖}protected void addIce() {System.out.println("加入冰块");}protected void addSugar() {System.out.println("加入糖");}
}public class CoffeeWithHooks extends BeverageWithHooks {private boolean wantsCondiments = true;private boolean wantsIce = false;private boolean wantsSugar = true;public void setWantsCondiments(boolean wantsCondiments) {this.wantsCondiments = wantsCondiments;}public void setWantsIce(boolean wantsIce) {this.wantsIce = wantsIce;}public void setWantsSugar(boolean wantsSugar) {this.wantsSugar = wantsSugar;}@Overrideprotected void brew() {System.out.println("用沸水冲泡咖啡");}@Overrideprotected void addCondiments() {System.out.println("加入牛奶");}@Overrideprotected boolean customerWantsCondiments() {return wantsCondiments;}@Overrideprotected boolean customerWantsIce() {return wantsIce;}@Overrideprotected boolean customerWantsSugar() {return wantsSugar;}
}public class TeaWithHooks extends BeverageWithHooks {private boolean wantsLemon = true;public void setWantsLemon(boolean wantsLemon) {this.wantsLemon = wantsLemon;}@Overrideprotected void brew() {System.out.println("用沸水浸泡茶叶");}@Overrideprotected void addCondiments() {if (wantsLemon) {System.out.println("加入柠檬");}}@Overrideprotected boolean customerWantsCondiments() {return wantsLemon;}@Overrideprotected boolean customerWantsSugar() {return false; // 茶通常不需要糖}
}
5.2.3 🔄 算法骨架实现
// 算法骨架：固定算法流程，可变步骤
public abstract class AlgorithmSkeleton {// 模板方法，定义算法骨架public final void execute() {initialize();preprocess();executeCore();postprocess();cleanup();}// 抽象方法，子类必须实现protected abstract void initialize();protected abstract void executeCore();// 钩子方法，子类可以选择覆盖protected void preprocess() {System.out.println("默认预处理");}protected void postprocess() {System.out.println("默认后处理");}protected void cleanup() {System.out.println("默认清理");}// 具体方法，所有子类共享protected void log(String message) {System.out.println("日志: " + message);}protected void validate() {System.out.println("验证数据");}
}public class SortingAlgorithm extends AlgorithmSkeleton {private int[] data;public SortingAlgorithm(int[] data) {this.data = data;}@Overrideprotected void initialize() {log("初始化排序算法");validate();}@Overrideprotected void executeCore() {log("执行排序");Arrays.sort(data);}@Overrideprotected void postprocess() {log("排序完成，结果: " + Arrays.toString(data));}
}public class SearchAlgorithm extends AlgorithmSkeleton {private int[] data;private int target;public SearchAlgorithm(int[] data, int target) {this.data = data;this.target = target;}@Overrideprotected void initialize() {log("初始化搜索算法");validate();}@Overrideprotected void preprocess() {log("预处理：对数据进行排序");Arrays.sort(data);}@Overrideprotected void executeCore() {log("执行二分搜索");int result = Arrays.binarySearch(data, target);if (result >= 0) {log("找到目标值，位置: " + result);} else {log("未找到目标值");}}@Overrideprotected void cleanup() {log("清理搜索资源");}
}public class CompressionAlgorithm extends AlgorithmSkeleton {private byte[] data;public CompressionAlgorithm(byte[] data) {this.data = data;}@Overrideprotected void initialize() {log("初始化压缩算法");validate();}@Overrideprotected void executeCore() {log("执行数据压缩");// 模拟压缩过程System.out.println("压缩前大小: " + data.length + " 字节");System.out.println("压缩后大小: " + (data.length / 2) + " 字节");}@Overrideprotected void postprocess() {log("压缩完成，计算压缩率");System.out.println("压缩率: 50%");}
}
5.2.3 🎯 标准实现示例
// 抽象类 - 定义算法骨架
public abstract class AbstractClass {// 模板方法 - 定义算法流程public final void templateMethod() {primitiveOperation1();primitiveOperation2();concreteOperation();hook();}// 抽象方法 - 子类必须实现protected abstract void primitiveOperation1();protected abstract void primitiveOperation2();// 具体方法 - 所有子类共享protected void concreteOperation() {System.out.println("具体操作");}// 钩子方法 - 子类可选覆盖protected void hook() {// 默认实现，子类可以覆盖}
}// 具体类A - 实现具体步骤
public class ConcreteClassA extends AbstractClass {@Overrideprotected void primitiveOperation1() {System.out.println("具体类A的操作1");}@Overrideprotected void primitiveOperation2() {System.out.println("具体类A的操作2");}
}// 具体类B - 实现具体步骤并覆盖钩子方法
public class ConcreteClassB extends AbstractClass {@Overrideprotected void primitiveOperation1() {System.out.println("具体类B的操作1");}@Overrideprotected void primitiveOperation2() {System.out.println("具体类B的操作2");}@Overrideprotected void hook() {System.out.println("具体类B的钩子方法");}
}
5.2.4 🎯 实际应用示例
// 饮料抽象类
public abstract class Beverage {// 模板方法public final void prepareBeverage() {boilWater();brew();pourInCup();if (customerWantsCondiments()) {addCondiments();}}// 抽象方法protected abstract void brew();protected abstract void addCondiments();// 具体方法protected void boilWater() {System.out.println("烧开水");}protected void pourInCup() {System.out.println("倒入杯中");}// 钩子方法protected boolean customerWantsCondiments() {return true;}
}// 咖啡
public class Coffee extends Beverage {@Overrideprotected void brew() {System.out.println("用沸水冲泡咖啡");}@Overrideprotected void addCondiments() {System.out.println("加入糖和牛奶");}
}// 茶
public class Tea extends Beverage {private boolean wantsCondiments = true;public void setWantsCondiments(boolean wantsCondiments) {this.wantsCondiments = wantsCondiments;}@Overrideprotected void brew() {System.out.println("用沸水浸泡茶叶");}@Overrideprotected void addCondiments() {System.out.println("加入柠檬");}@Overrideprotected boolean customerWantsCondiments() {return wantsCondiments;}
}

🔍 第六部分：迭代器模式（Iterator Pattern）

🔍 迭代舞者的登场 🔍
┌─────────────────────────────────────┐
│  🔍 迭代者：我是集合遍历专家！      │
│                                     │
│  📚 书架："我有好多书！"            │
│  🔍 迭代者："我来遍历它们！"        │
│  📚 书架："我有不同结构！"          │
│  🔍 迭代者："继续遍历它们！"        │
│                                     │
│  💡 核心思想：统一遍历接口          │
└─────────────────────────────────────┘

🏗️ 迭代器模式UML类图

uses
uses
implements
implements
references
«interface»
Iterator
+hasNext()
+next()
+remove()
«interface»
Aggregate
+createIterator()
ConcreteIterator
-aggregate: ConcreteAggregate
-current: int
+hasNext()
+next()
+remove()
ConcreteAggregate
-items: List
+add(item)
+get(index)
+size()
+createIterator()
Client
+useIterator()

⏱️ 迭代器模式时序图

客户端聚合迭代器createIterator()iteratorhasNext()truenext()itemhasNext()false客户端聚合迭代器

6.1 🎭 什么是迭代器模式？

一句话理解：提供统一的接口来遍历集合，隐藏内部结构！

定义：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

应用场景：集合遍历、数据结构访问、分页查询、数据库结果集

6.2 🛠️ 迭代器模式的实现

6.2.1 🏗️ 基本结构

💡 小贴士：迭代器模式就像图书馆的图书管理员，统一管理各种书籍的访问方式！

核心组件：

  • Iterator（迭代器）：定义访问元素的接口
  • ConcreteIterator（具体迭代器）：实现迭代器接口
  • Aggregate（聚合）：定义创建迭代器的接口
  • ConcreteAggregate（具体聚合）：实现聚合接口
6.2.2 🚀 多种实现方式
实现方式特点推荐度
外部迭代器客户端控制迭代过程⭐⭐⭐⭐
内部迭代器聚合对象控制迭代过程⭐⭐⭐
泛型迭代器支持不同类型的元素⭐⭐⭐⭐⭐

外部迭代器实现：

// 外部迭代器：客户端控制迭代过程
public interface ExternalIterator<T> {boolean hasNext();T next();void remove();
}public interface ExternalAggregate<T> {ExternalIterator<T> createIterator();
}public class BookShelf implements ExternalAggregate<Book> {private List<Book> books = new ArrayList<>();public void appendBook(Book book) {books.add(book);}public Book getBookAt(int index) {return books.get(index);}public int getLength() {return books.size();}@Overridepublic ExternalIterator<Book> createIterator() {return new BookShelfIterator(this);}
}public class BookShelfIterator implements ExternalIterator<Book> {private BookShelf bookShelf;private int index;public BookShelfIterator(BookShelf bookShelf) {this.bookShelf = bookShelf;this.index = 0;}@Overridepublic boolean hasNext() {return index < bookShelf.getLength();}@Overridepublic Book next() {if (hasNext()) {return bookShelf.getBookAt(index++);}throw new NoSuchElementException();}@Overridepublic void remove() {// 实现删除逻辑throw new UnsupportedOperationException("不支持删除操作");}
}public class Book {private String name;private String author;public Book(String name, String author) {this.name = name;this.author = author;}public String getName() {return name;}public String getAuthor() {return author;}@Overridepublic String toString() {return "《" + name + "》 by " + author;}
}
6.2.2 🔄 内部迭代器实现
// 内部迭代器：聚合对象控制迭代过程
public interface InternalIterator<T> {void iterate(Consumer<T> action);
}public class BookShelfInternal implements InternalIterator<Book> {private List<Book> books = new ArrayList<>();public void appendBook(Book book) {books.add(book);}@Overridepublic void iterate(Consumer<Book> action) {for (Book book : books) {action.accept(book);}}// 提供过滤功能public void iterateWithFilter(Predicate<Book> filter, Consumer<Book> action) {for (Book book : books) {if (filter.test(book)) {action.accept(book);}}}// 提供转换功能public <R> List<R> map(Function<Book, R> mapper) {List<R> result = new ArrayList<>();for (Book book : books) {result.add(mapper.apply(book));}return result;}
}// 使用示例
public class InternalIteratorDemo {public static void main(String[] args) {BookShelfInternal shelf = new BookShelfInternal();shelf.appendBook(new Book("Java编程思想", "Bruce Eckel"));shelf.appendBook(new Book("设计模式", "GoF"));shelf.appendBook(new Book("算法导论", "Thomas H. Cormen"));// 简单迭代System.out.println("=== 所有书籍 ===");shelf.iterate(book -> System.out.println(book));// 过滤迭代System.out.println("\n=== Java相关书籍 ===");shelf.iterateWithFilter(book -> book.getName().contains("Java"),book -> System.out.println(book));// 转换迭代System.out.println("\n=== 书籍名称列表 ===");List<String> bookNames = shelf.map(Book::getName);bookNames.forEach(System.out::println);}
}

泛型迭代器实现：

// 泛型迭代器：支持不同类型的元素
public interface GenericIterator<T> {boolean hasNext();T next();void remove();void reset();
}public interface GenericAggregate<T> {GenericIterator<T> createIterator();int size();T get(int index);void add(T element);void remove(T element);
}public class GenericList<T> implements GenericAggregate<T> {private List<T> elements = new ArrayList<>();@Overridepublic GenericIterator<T> createIterator() {return new GenericListIterator<>(this);}@Overridepublic int size() {return elements.size();}@Overridepublic T get(int index) {return elements.get(index);}@Overridepublic void add(T element) {elements.add(element);}@Overridepublic void remove(T element) {elements.remove(element);}
}public class GenericListIterator<T> implements GenericIterator<T> {private GenericAggregate<T> aggregate;private int currentIndex;public GenericListIterator(GenericAggregate<T> aggregate) {this.aggregate = aggregate;this.currentIndex = 0;}@Overridepublic boolean hasNext() {return currentIndex < aggregate.size();}@Overridepublic T next() {if (hasNext()) {return aggregate.get(currentIndex++);}throw new NoSuchElementException();}@Overridepublic void remove() {// 实现删除逻辑throw new UnsupportedOperationException("不支持删除操作");}@Overridepublic void reset() {currentIndex = 0;}
}// 双向迭代器
public interface BidirectionalIterator<T> extends GenericIterator<T> {boolean hasPrevious();T previous();int nextIndex();int previousIndex();
}public class BidirectionalListIterator<T> implements BidirectionalIterator<T> {private GenericAggregate<T> aggregate;private int currentIndex;public BidirectionalListIterator(GenericAggregate<T> aggregate) {this.aggregate = aggregate;this.currentIndex = 0;}@Overridepublic boolean hasNext() {return currentIndex < aggregate.size();}@Overridepublic T next() {if (hasNext()) {return aggregate.get(currentIndex++);}throw new NoSuchElementException();}@Overridepublic boolean hasPrevious() {return currentIndex > 0;}@Overridepublic T previous() {if (hasPrevious()) {return aggregate.get(--currentIndex);}throw new NoSuchElementException();}@Overridepublic int nextIndex() {return currentIndex;}@Overridepublic int previousIndex() {return currentIndex - 1;}@Overridepublic void remove() {throw new UnsupportedOperationException("不支持删除操作");}@Overridepublic void reset() {currentIndex = 0;}
}// 使用示例
public class GenericIteratorDemo {public static void main(String[] args) {// 字符串列表GenericList<String> stringList = new GenericList<>();stringList.add("Apple");stringList.add("Banana");stringList.add("Cherry");System.out.println("=== 字符串列表 ===");GenericIterator<String> stringIterator = stringList.createIterator();while (stringIterator.hasNext()) {System.out.println(stringIterator.next());}// 整数列表GenericList<Integer> intList = new GenericList<>();intList.add(1);intList.add(2);intList.add(3);intList.add(4);intList.add(5);System.out.println("\n=== 整数列表 ===");GenericIterator<Integer> intIterator = intList.createIterator();while (intIterator.hasNext()) {System.out.println(intIterator.next());}// 双向迭代System.out.println("\n=== 双向迭代 ===");BidirectionalIterator<Integer> biIterator = new BidirectionalListIterator<>(intList);while (biIterator.hasNext()) {System.out.println("前进: " + biIterator.next());}while (biIterator.hasPrevious()) {System.out.println("后退: " + biIterator.previous());}}
}
6.2.3 🎯 标准实现示例
// 迭代器接口 - 定义遍历操作
public interface Iterator<T> {boolean hasNext();T next();void remove();
}// 聚合接口 - 定义创建迭代器的方法
public interface Aggregate<T> {Iterator<T> createIterator();
}// 具体聚合 - 实现聚合接口
public class ConcreteAggregate<T> implements Aggregate<T> {private List<T> items = new ArrayList<>();public void add(T item) {items.add(item);}public T get(int index) {return items.get(index);}public int size() {return items.size();}@Overridepublic Iterator<T> createIterator() {return new ConcreteIterator<>(this);}
}// 具体迭代器 - 实现遍历逻辑
public class ConcreteIterator<T> implements Iterator<T> {private ConcreteAggregate<T> aggregate;private int current = 0;public ConcreteIterator(ConcreteAggregate<T> aggregate) {this.aggregate = aggregate;}@Overridepublic boolean hasNext() {return current < aggregate.size();}@Overridepublic T next() {if (hasNext()) {return aggregate.get(current++);}throw new NoSuchElementException();}@Overridepublic void remove() {// 实现删除逻辑}
}
6.2.4 🎯 实际应用示例
// 书类
public class Book {private String name;private String author;public Book(String name, String author) {this.name = name;this.author = author;}public String getName() {return name;}public String getAuthor() {return author;}@Overridepublic String toString() {return "《" + name + "》 by " + author;}
}// 书架
public class BookShelf implements Aggregate<Book> {private List<Book> books = new ArrayList<>();public void appendBook(Book book) {books.add(book);}public Book getBookAt(int index) {return books.get(index);}public int getLength() {return books.size();}@Overridepublic Iterator<Book> createIterator() {return new BookShelfIterator(this);}
}// 书架迭代器
public class BookShelfIterator implements Iterator<Book> {private BookShelf bookShelf;private int index;public BookShelfIterator(BookShelf bookShelf) {this.bookShelf = bookShelf;this.index = 0;}@Overridepublic boolean hasNext() {return index < bookShelf.getLength();}@Overridepublic Book next() {if (hasNext()) {return bookShelf.getBookAt(index++);}throw new NoSuchElementException();}@Overridepublic void remove() {// 实现删除逻辑}
}

⛓️ 第七部分：责任链模式（Chain of Responsibility Pattern）

⛓️ 责任链舞者的登场 ⛓️
┌─────────────────────────────────────┐
│  ⛓️ 责任链：我是请求处理链！        │
│                                     │
│  📝 请求："我要请假3天！"           │
│  ⛓️ 责任链："我来传递请求！"        │
│  📝 请求："我要请假10天！"          │
│  ⛓️ 责任链："继续传递请求！"        │
│                                     │
│  💡 核心思想：请求沿链传递          │
└─────────────────────────────────────┘

🏗️ 责任链模式UML类图

uses
extends
extends
extends
references
«abstract»
Handler
-successor: Handler
+setSuccessor(successor)
+handleRequest(request)
ConcreteHandlerA
+handleRequest(request)
ConcreteHandlerB
+handleRequest(request)
ConcreteHandlerC
+handleRequest(request)
Client
+useChain()

⏱️ 责任链模式时序图

客户端处理器A处理器B处理器ChandleRequest(request)canHandle(request)handleRequest(request)canHandle(request)handleRequest(request)canHandle(request)resultresultresult客户端处理器A处理器B处理器C

7.1 🎭 什么是责任链模式？

一句话理解：请求沿着处理链传递，直到找到合适的处理器！

定义：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。

应用场景：请求处理、异常处理、过滤器链、审批流程、日志处理

7.2 🛠️ 责任链模式的实现

7.2.1 🏗️ 基本结构

💡 小贴士：责任链模式就像公司审批流程，请求沿着链条传递，直到被处理！

核心组件：

  • Handler（处理器）：定义处理请求的接口
  • ConcreteHandler（具体处理器）：实现处理器接口
  • Client（客户端）：发起请求的对象
7.2.2 🚀 多种实现方式
实现方式特点推荐度
纯责任链请求必须被处理⭐⭐⭐⭐
不纯责任链请求可能不被处理⭐⭐⭐
动态责任链运行时动态构建链⭐⭐⭐⭐⭐
7.2.1 ⛓️ 纯责任链实现
// 纯责任链：请求必须被处理
public abstract class PureHandler {protected PureHandler successor;public void setSuccessor(PureHandler successor) {this.successor = successor;}public abstract void handleRequest(int request);
}public class ConcreteHandlerA extends PureHandler {@Overridepublic void handleRequest(int request) {if (request >= 0 && request < 10) {System.out.println("处理器A处理请求: " + request);} else if (successor != null) {successor.handleRequest(request);} else {// 纯责任链：必须有处理器处理请求System.out.println("默认处理器处理请求: " + request);}}
}public class ConcreteHandlerB extends PureHandler {@Overridepublic void handleRequest(int request) {if (request >= 10 && request < 20) {System.out.println("处理器B处理请求: " + request);} else if (successor != null) {successor.handleRequest(request);} else {System.out.println("默认处理器处理请求: " + request);}}
}public class ConcreteHandlerC extends PureHandler {@Overridepublic void handleRequest(int request) {if (request >= 20 && request < 30) {System.out.println("处理器C处理请求: " + request);} else if (successor != null) {successor.handleRequest(request);} else {System.out.println("默认处理器处理请求: " + request);}}
}public class DefaultHandler extends PureHandler {@Overridepublic void handleRequest(int request) {System.out.println("默认处理器处理请求: " + request);}
}

不纯责任链实现：

// 不纯责任链：请求可能不被处理
public abstract class ImpureHandler {protected ImpureHandler successor;public void setSuccessor(ImpureHandler successor) {this.successor = successor;}public abstract boolean handleRequest(int request);
}public class ImpureHandlerA extends ImpureHandler {@Overridepublic boolean handleRequest(int request) {if (request >= 0 && request < 10) {System.out.println("处理器A处理请求: " + request);return true; // 请求被处理} else if (successor != null) {return successor.handleRequest(request);} else {System.out.println("请求未被处理: " + request);return false; // 请求未被处理}}
}public class ImpureHandlerB extends ImpureHandler {@Overridepublic boolean handleRequest(int request) {if (request >= 10 && request < 20) {System.out.println("处理器B处理请求: " + request);return true;} else if (successor != null) {return successor.handleRequest(request);} else {System.out.println("请求未被处理: " + request);return false;}}
}public class ImpureHandlerC extends ImpureHandler {@Overridepublic boolean handleRequest(int request) {if (request >= 20 && request < 30) {System.out.println("处理器C处理请求: " + request);return true;} else if (successor != null) {return successor.handleRequest(request);} else {System.out.println("请求未被处理: " + request);return false;}}
}

动态责任链实现：

// 动态责任链：运行时动态构建链
public interface DynamicHandler {boolean handle(Request request);void setNext(DynamicHandler next);DynamicHandler getNext();
}public class Request {private String type;private Object data;private Map<String, Object> context = new HashMap<>();public Request(String type, Object data) {this.type = type;this.data = data;}public String getType() {return type;}public Object getData() {return data;}public void setContext(String key, Object value) {context.put(key, value);}public Object getContext(String key) {return context.get(key);}
}public class AuthenticationHandler implements DynamicHandler {private DynamicHandler next;@Overridepublic boolean handle(Request request) {System.out.println("认证处理器处理请求: " + request.getType());// 模拟认证逻辑if ("admin".equals(request.getContext("user"))) {request.setContext("authenticated", true);System.out.println("认证成功");return next != null ? next.handle(request) : true;} else {System.out.println("认证失败");return false;}}@Overridepublic void setNext(DynamicHandler next) {this.next = next;}@Overridepublic DynamicHandler getNext() {return next;}
}public class AuthorizationHandler implements DynamicHandler {private DynamicHandler next;@Overridepublic boolean handle(Request request) {System.out.println("授权处理器处理请求: " + request.getType());// 模拟授权逻辑if (Boolean.TRUE.equals(request.getContext("authenticated"))) {request.setContext("authorized", true);System.out.println("授权成功");return next != null ? next.handle(request) : true;} else {System.out.println("授权失败");return false;}}@Overridepublic void setNext(DynamicHandler next) {this.next = next;}@Overridepublic DynamicHandler getNext() {return next;}
}public class LoggingHandler implements DynamicHandler {private DynamicHandler next;@Overridepublic boolean handle(Request request) {System.out.println("日志处理器处理请求: " + request.getType());System.out.println("记录请求日志: " + request.getData());boolean result = next != null ? next.handle(request) : true;System.out.println("请求处理结果: " + result);return result;}@Overridepublic void setNext(DynamicHandler next) {this.next = next;}@Overridepublic DynamicHandler getNext() {return next;}
}public class BusinessHandler implements DynamicHandler {private DynamicHandler next;@Overridepublic boolean handle(Request request) {System.out.println("业务处理器处理请求: " + request.getType());// 模拟业务逻辑if (Boolean.TRUE.equals(request.getContext("authorized"))) {System.out.println("执行业务逻辑: " + request.getData());return true;} else {System.out.println("业务处理失败：未授权");return false;}}@Overridepublic void setNext(DynamicHandler next) {this.next = next;}@Overridepublic DynamicHandler getNext() {return next;}
}public class DynamicChainBuilder {private List<DynamicHandler> handlers = new ArrayList<>();public DynamicChainBuilder addHandler(DynamicHandler handler) {handlers.add(handler);return this;}public DynamicHandler build() {if (handlers.isEmpty()) {return null;}// 构建责任链for (int i = 0; i < handlers.size() - 1; i++) {handlers.get(i).setNext(handlers.get(i + 1));}return handlers.get(0);}
}// 使用示例
public class DynamicChainDemo {public static void main(String[] args) {// 动态构建责任链DynamicChainBuilder builder = new DynamicChainBuilder();DynamicHandler chain = builder.addHandler(new LoggingHandler()).addHandler(new AuthenticationHandler()).addHandler(new AuthorizationHandler()).addHandler(new BusinessHandler()).build();// 创建请求Request request = new Request("userAction", "执行用户操作");request.setContext("user", "admin");// 处理请求System.out.println("=== 处理请求 ===");boolean result = chain.handle(request);System.out.println("最终结果: " + result);// 动态修改责任链System.out.println("\n=== 动态修改责任链 ===");DynamicChainBuilder newBuilder = new DynamicChainBuilder();DynamicHandler newChain = newBuilder.addHandler(new LoggingHandler()).addHandler(new BusinessHandler()).build();Request newRequest = new Request("simpleAction", "简单操作");boolean newResult = newChain.handle(newRequest);System.out.println("新链处理结果: " + newResult);}
}
7.2.3 🎯 标准实现示例
// 处理器抽象类 - 定义处理请求的接口
public abstract class Handler {protected Handler successor;public void setSuccessor(Handler successor) {this.successor = successor;}public abstract void handleRequest(int request);
}// 具体处理器A - 处理特定范围的请求
public class ConcreteHandlerA extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 0 && request < 10) {System.out.println("处理器A处理请求: " + request);} else if (successor != null) {successor.handleRequest(request);}}
}// 具体处理器B - 处理特定范围的请求
public class ConcreteHandlerB extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 10 && request < 20) {System.out.println("处理器B处理请求: " + request);} else if (successor != null) {successor.handleRequest(request);}}
}// 具体处理器C - 处理特定范围的请求
public class ConcreteHandlerC extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 20 && request < 30) {System.out.println("处理器C处理请求: " + request);} else if (successor != null) {successor.handleRequest(request);} else {System.out.println("没有处理器能处理请求: " + request);}}
}
7.2.4 🎯 实际应用示例
// 请假请求
public class LeaveRequest {private String name;private int leaveDays;private String reason;public LeaveRequest(String name, int leaveDays, String reason) {this.name = name;this.leaveDays = leaveDays;this.reason = reason;}public String getName() {return name;}public int getLeaveDays() {return leaveDays;}public String getReason() {return reason;}
}// 审批者抽象类
public abstract class Approver {protected Approver successor;protected String name;public Approver(String name) {this.name = name;}public void setSuccessor(Approver successor) {this.successor = successor;}public abstract void processRequest(LeaveRequest request);
}// 组长
public class GroupLeader extends Approver {public GroupLeader(String name) {super(name);}@Overridepublic void processRequest(LeaveRequest request) {if (request.getLeaveDays() <= 3) {System.out.println("组长 " + name + " 审批员工 " + request.getName() +" 的请假申请，请假天数：" + request.getLeaveDays() + " 天");} else if (successor != null) {successor.processRequest(request);}}
}// 经理
public class Manager extends Approver {public Manager(String name) {super(name);}@Overridepublic void processRequest(LeaveRequest request) {if (request.getLeaveDays() <= 7) {System.out.println("经理 " + name + " 审批员工 " + request.getName() +" 的请假申请，请假天数：" + request.getLeaveDays() + " 天");} else if (successor != null) {successor.processRequest(request);}}
}
http://www.lryc.cn/news/623246.html

相关文章：

  • 从0到1掌握 Spring Security（第三篇）：三种认证方式，按配置一键切换
  • RH134 访问网络附加存储知识点
  • 从舒适度提升到能耗降低再到安全保障，楼宇自控作用关键
  • 19.3 Transformers量化模型极速加载指南：4倍推理加速+75%显存节省实战
  • 立体匹配中的稠密匹配和稀疏匹配
  • RK3568 NPU RKNN（二）：RKNN-ToolKit2环境搭建
  • 《MySQL 数据库备份与视图创建全流程：从数据迁移到高效查询实战》
  • MySQL的下载安装（MSI和ZIP版本都有）
  • 利用Qwen大模型进行c++11并发库的学习，与时俱进！！！！
  • 从频繁告警到平稳发布：服务冷启动 CPU 风暴优化实践01
  • 同创物流学习记录1
  • 发文暴论！线性注意力is all you need！
  • 【leetcode】12. 整数转罗马数字
  • 双椒派E2000D开发板LED驱动开发实战指南
  • 【手撕JAVA多线程】1.从设计初衷去看JAVA的线程操作
  • ESP32 C3 开发板使用教程 01-测试显示屏
  • 数据结构之heap算法
  • ollama 自定义模型
  • 黑板架构详解
  • jd-hotkey探测热点key
  • 深入理解 Linux 线程：从概念到虚拟地址空间的全面解析
  • 第5问 对于数据分析领域，统计学要学到什么程度？
  • 2025年睿抗国赛本科组题解
  • 《C语言程序设计》笔记p10
  • 【数据结构入门】二叉树（2）
  • 【数据结构】-2- 泛型
  • Day15 Docker
  • KNN 算法详解：从电影分类到鸢尾花识别的实战指南
  • GaussDB 数据库架构师修炼(十三)安全管理(4)-数据库审计
  • androidstudio内存大小配置