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

是2的10次方啊2025-08-16 17:04

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

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

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

🏗️ 状态模式UML类图

4.1 🎭 什么是状态模式？

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

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

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

4.2 🛠️ 状态模式的实现

4.2.1 🏗️ 基本结构

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

核心组件：

  • State（状态） ：状态的抽象接口
  • ConcreteState（具体状态） ：具体的状态实现
  • Context（上下文） ：维护当前状态的对象

4.2.2 🚀 多种实现方式

实现方式 特点 推荐度
状态接口 通过接口定义状态行为 ⭐⭐⭐⭐⭐
状态枚举 使用枚举简化状态管理 ⭐⭐⭐⭐
状态机 复杂状态转换逻辑 ⭐⭐⭐⭐⭐

状态接口实现：

csharp 复制代码 
// 状态接口：通过接口定义状态行为
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;
    }

    @Override
    public void insertCoin() {
        System.out.println("投币成功");
        vendingMachine.setState(vendingMachine.getHasCoinState());
    }

    @Override
    public void ejectCoin() {
        System.out.println("没有投币，无法退币");
    }

    @Override
    public void selectProduct() {
        System.out.println("请先投币");
    }

    @Override
    public void dispense() {
        System.out.println("请先投币");
    }
}

public class HasCoinState implements VendingMachineState {
    private VendingMachine vendingMachine;

    public HasCoinState(VendingMachine vendingMachine) {
        this.vendingMachine = vendingMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("已经投币，请选择商品");
    }

    @Override
    public void ejectCoin() {
        System.out.println("退币成功");
        vendingMachine.setState(vendingMachine.getNoCoinState());
    }

    @Override
    public void selectProduct() {
        System.out.println("选择商品成功");
        vendingMachine.setState(vendingMachine.getSoldState());
    }

    @Override
    public void dispense() {
        System.out.println("请先选择商品");
    }
}

public class SoldState implements VendingMachineState {
    private VendingMachine vendingMachine;

    public SoldState(VendingMachine vendingMachine) {
        this.vendingMachine = vendingMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("请等待商品出货");
    }

    @Override
    public void ejectCoin() {
        System.out.println("商品已选择，无法退币");
    }

    @Override
    public void selectProduct() {
        System.out.println("商品已选择，请等待出货");
    }

    @Override
    public 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;
    }

    @Override
    public void insertCoin() {
        System.out.println("商品已售罄，无法投币");
    }

    @Override
    public void ejectCoin() {
        System.out.println("没有投币，无法退币");
    }

    @Override
    public void selectProduct() {
        System.out.println("商品已售罄");
    }

    @Override
    public 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 states
    public VendingMachineState getNoCoinState() {
        return noCoinState;
    }

    public VendingMachineState getHasCoinState() {
        return hasCoinState;
    }

    public VendingMachineState getSoldState() {
        return soldState;
    }

    public VendingMachineState getSoldOutState() {
        return soldOutState;
    }
}

状态枚举实现：

typescript 复制代码 
// 状态枚举：使用枚举简化状态管理
public enum OrderState {
    PENDING {
        @Override
        public void process(Order order) {
            System.out.println("订单待处理，开始处理...");
            order.setState(PROCESSING);
        }

        @Override
        public void cancel(Order order) {
            System.out.println("订单取消");
            order.setState(CANCELLED);
        }

        @Override
        public void ship(Order order) {
            System.out.println("订单还未处理，无法发货");
        }

        @Override
        public void deliver(Order order) {
            System.out.println("订单还未发货，无法交付");
        }
    },

    PROCESSING {
        @Override
        public void process(Order order) {
            System.out.println("订单正在处理中...");
        }

        @Override
        public void cancel(Order order) {
            System.out.println("订单处理中，无法取消");
        }

        @Override
        public void ship(Order order) {
            System.out.println("订单处理完成，开始发货");
            order.setState(SHIPPED);
        }

        @Override
        public void deliver(Order order) {
            System.out.println("订单还未发货，无法交付");
        }
    },

    SHIPPED {
        @Override
        public void process(Order order) {
            System.out.println("订单已发货，无法重新处理");
        }

        @Override
        public void cancel(Order order) {
            System.out.println("订单已发货，无法取消");
        }

        @Override
        public void ship(Order order) {
            System.out.println("订单已发货");
        }

        @Override
        public void deliver(Order order) {
            System.out.println("订单交付完成");
            order.setState(DELIVERED);
        }
    },

    DELIVERED {
        @Override
        public void process(Order order) {
            System.out.println("订单已交付，无法重新处理");
        }

        @Override
        public void cancel(Order order) {
            System.out.println("订单已交付，无法取消");
        }

        @Override
        public void ship(Order order) {
            System.out.println("订单已交付，无法重新发货");
        }

        @Override
        public void deliver(Order order) {
            System.out.println("订单已交付");
        }
    },

    CANCELLED {
        @Override
        public void process(Order order) {
            System.out.println("订单已取消，无法处理");
        }

        @Override
        public void cancel(Order order) {
            System.out.println("订单已取消");
        }

        @Override
        public void ship(Order order) {
            System.out.println("订单已取消，无法发货");
        }

        @Override
        public 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 ⚙️ 状态机实现

csharp 复制代码 
// 状态机：复杂状态转换逻辑
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 🎯 标准实现示例

csharp 复制代码 
// 状态接口 - 定义状态的行为
public interface State {
    void handle();
}

// 具体状态A - 实现状态A的行为
public class ConcreteStateA implements State {
    private Context context;

    public ConcreteStateA(Context context) {
        this.context = context;
    }

    @Override
    public 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;
    }

    @Override
    public 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 🎯 实际应用示例

csharp 复制代码 
// 售货机状态接口
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;
    }

    @Override
    public void insertCoin() {
        System.out.println("投币成功");
        vendingMachine.setState(vendingMachine.getHasCoinState());
    }

    @Override
    public void ejectCoin() {
        System.out.println("没有投币，无法退币");
    }

    @Override
    public void selectProduct() {
        System.out.println("请先投币");
    }

    @Override
    public void dispense() {
        System.out.println("请先投币");
    }
}

// 有币状态
public class HasCoinState implements VendingMachineState {
    private VendingMachine vendingMachine;

    public HasCoinState(VendingMachine vendingMachine) {
        this.vendingMachine = vendingMachine;
    }

    @Override
    public void insertCoin() {
        System.out.println("已经投币，请选择商品");
    }

    @Override
    public void ejectCoin() {
        System.out.println("退币成功");
        vendingMachine.setState(vendingMachine.getNoCoinState());
    }

    @Override
    public void selectProduct() {
        System.out.println("选择商品成功");
        vendingMachine.setState(vendingMachine.getSoldState());
    }

    @Override
    public 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）

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

🏗️ 模板方法模式UML类图

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

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

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

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

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

5.2.1 🏗️ 基本结构

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

核心组件：

  • AbstractClass（抽象类） ：定义算法框架
  • ConcreteClass（具体类） ：实现具体步骤
  • Template Method（模板方法） ：定义算法骨架

5.2.2 🚀 多种实现方式

实现方式 特点 推荐度
抽象类 通过抽象类定义模板 ⭐⭐⭐⭐⭐
钩子方法 提供默认实现的可选方法 ⭐⭐⭐⭐⭐
算法骨架 固定算法流程，可变步骤 ⭐⭐⭐⭐⭐

5.2.1 🏗️ 抽象类实现

csharp 复制代码 
// 抽象类：通过抽象类定义模板
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 {
    @Override
    protected void readData() {
        System.out.println("读取CSV文件");
    }

    @Override
    protected void processData() {
        System.out.println("处理CSV数据");
    }

    @Override
    protected void writeData() {
        System.out.println("写入CSV文件");
    }
}

public class JSONProcessor extends DataProcessor {
    @Override
    protected void readData() {
        System.out.println("读取JSON文件");
    }

    @Override
    protected void processData() {
        System.out.println("处理JSON数据");
    }

    @Override
    protected void writeData() {
        System.out.println("写入JSON文件");
    }
}

public class XMLProcessor extends DataProcessor {
    @Override
    protected void readData() {
        System.out.println("读取XML文件");
    }

    @Override
    protected void processData() {
        System.out.println("处理XML数据");
    }

    @Override
    protected void writeData() {
        System.out.println("写入XML文件");
    }
}

5.2.2 🎣 钩子方法实现

typescript 复制代码 
// 钩子方法：提供默认实现的可选方法
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;
    }

    @Override
    protected void brew() {
        System.out.println("用沸水冲泡咖啡");
    }

    @Override
    protected void addCondiments() {
        System.out.println("加入牛奶");
    }

    @Override
    protected boolean customerWantsCondiments() {
        return wantsCondiments;
    }

    @Override
    protected boolean customerWantsIce() {
        return wantsIce;
    }

    @Override
    protected boolean customerWantsSugar() {
        return wantsSugar;
    }
}

public class TeaWithHooks extends BeverageWithHooks {
    private boolean wantsLemon = true;

    public void setWantsLemon(boolean wantsLemon) {
        this.wantsLemon = wantsLemon;
    }

    @Override
    protected void brew() {
        System.out.println("用沸水浸泡茶叶");
    }

    @Override
    protected void addCondiments() {
        if (wantsLemon) {
            System.out.println("加入柠檬");
        }
    }

    @Override
    protected boolean customerWantsCondiments() {
        return wantsLemon;
    }

    @Override
    protected boolean customerWantsSugar() {
        return false; // 茶通常不需要糖
    }
}

5.2.3 🔄 算法骨架实现

csharp 复制代码 
// 算法骨架：固定算法流程，可变步骤
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;
    }

    @Override
    protected void initialize() {
        log("初始化排序算法");
        validate();
    }

    @Override
    protected void executeCore() {
        log("执行排序");
        Arrays.sort(data);
    }

    @Override
    protected 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;
    }

    @Override
    protected void initialize() {
        log("初始化搜索算法");
        validate();
    }

    @Override
    protected void preprocess() {
        log("预处理：对数据进行排序");
        Arrays.sort(data);
    }

    @Override
    protected void executeCore() {
        log("执行二分搜索");
        int result = Arrays.binarySearch(data, target);
        if (result >= 0) {
            log("找到目标值，位置: " + result);
        } else {
            log("未找到目标值");
        }
    }

    @Override
    protected void cleanup() {
        log("清理搜索资源");
    }
}

public class CompressionAlgorithm extends AlgorithmSkeleton {
    private byte[] data;

    public CompressionAlgorithm(byte[] data) {
        this.data = data;
    }

    @Override
    protected void initialize() {
        log("初始化压缩算法");
        validate();
    }

    @Override
    protected void executeCore() {
        log("执行数据压缩");
        // 模拟压缩过程
        System.out.println("压缩前大小: " + data.length + " 字节");
        System.out.println("压缩后大小: " + (data.length / 2) + " 字节");
    }

    @Override
    protected void postprocess() {
        log("压缩完成，计算压缩率");
        System.out.println("压缩率: 50%");
    }
}

5.2.3 🎯 标准实现示例

csharp 复制代码 
// 抽象类 - 定义算法骨架
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 {
    @Override
    protected void primitiveOperation1() {
        System.out.println("具体类A的操作1");
    }

    @Override
    protected void primitiveOperation2() {
        System.out.println("具体类A的操作2");
    }
}

// 具体类B - 实现具体步骤并覆盖钩子方法
public class ConcreteClassB extends AbstractClass {
    @Override
    protected void primitiveOperation1() {
        System.out.println("具体类B的操作1");
    }

    @Override
    protected void primitiveOperation2() {
        System.out.println("具体类B的操作2");
    }

    @Override
    protected void hook() {
        System.out.println("具体类B的钩子方法");
    }
}

5.2.4 🎯 实际应用示例

csharp 复制代码 
// 饮料抽象类
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 {
    @Override
    protected void brew() {
        System.out.println("用沸水冲泡咖啡");
    }

    @Override
    protected void addCondiments() {
        System.out.println("加入糖和牛奶");
    }
}

// 茶
public class Tea extends Beverage {
    private boolean wantsCondiments = true;

    public void setWantsCondiments(boolean wantsCondiments) {
        this.wantsCondiments = wantsCondiments;
    }

    @Override
    protected void brew() {
        System.out.println("用沸水浸泡茶叶");
    }

    @Override
    protected void addCondiments() {
        System.out.println("加入柠檬");
    }

    @Override
    protected boolean customerWantsCondiments() {
        return wantsCondiments;
    }
}

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

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

🏗️ 迭代器模式UML类图

6.1 🎭 什么是迭代器模式？

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

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

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

6.2 🛠️ 迭代器模式的实现

6.2.1 🏗️ 基本结构

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

核心组件：

  • Iterator（迭代器） ：定义访问元素的接口
  • ConcreteIterator（具体迭代器） ：实现迭代器接口
  • Aggregate（聚合） ：定义创建迭代器的接口
  • ConcreteAggregate（具体聚合） ：实现聚合接口

6.2.2 🚀 多种实现方式

实现方式 特点 推荐度
外部迭代器 客户端控制迭代过程 ⭐⭐⭐⭐
内部迭代器 聚合对象控制迭代过程 ⭐⭐⭐
泛型迭代器 支持不同类型的元素 ⭐⭐⭐⭐⭐

外部迭代器实现：

csharp 复制代码 
// 外部迭代器：客户端控制迭代过程
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();
    }

    @Override
    public 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;
    }

    @Override
    public boolean hasNext() {
        return index < bookShelf.getLength();
    }

    @Override
    public Book next() {
        if (hasNext()) {
            return bookShelf.getBookAt(index++);
        }
        throw new NoSuchElementException();
    }

    @Override
    public 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;
    }

    @Override
    public String toString() {
        return "《" + name + "》 by " + author;
    }
}

6.2.2 🔄 内部迭代器实现

csharp 复制代码 
// 内部迭代器：聚合对象控制迭代过程
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);
    }

    @Override
    public 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);
    }
}

泛型迭代器实现：

csharp 复制代码 
// 泛型迭代器：支持不同类型的元素
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<>();

    @Override
    public GenericIterator<T> createIterator() {
        return new GenericListIterator<>(this);
    }

    @Override
    public int size() {
        return elements.size();
    }

    @Override
    public T get(int index) {
        return elements.get(index);
    }

    @Override
    public void add(T element) {
        elements.add(element);
    }

    @Override
    public 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;
    }

    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.size();
    }

    @Override
    public T next() {
        if (hasNext()) {
            return aggregate.get(currentIndex++);
        }
        throw new NoSuchElementException();
    }

    @Override
    public void remove() {
        // 实现删除逻辑
        throw new UnsupportedOperationException("不支持删除操作");
    }

    @Override
    public 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;
    }

    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.size();
    }

    @Override
    public T next() {
        if (hasNext()) {
            return aggregate.get(currentIndex++);
        }
        throw new NoSuchElementException();
    }

    @Override
    public boolean hasPrevious() {
        return currentIndex > 0;
    }

    @Override
    public T previous() {
        if (hasPrevious()) {
            return aggregate.get(--currentIndex);
        }
        throw new NoSuchElementException();
    }

    @Override
    public int nextIndex() {
        return currentIndex;
    }

    @Override
    public int previousIndex() {
        return currentIndex - 1;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("不支持删除操作");
    }

    @Override
    public 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 🎯 标准实现示例

csharp 复制代码 
// 迭代器接口 - 定义遍历操作
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();
    }

    @Override
    public 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;
    }

    @Override
    public boolean hasNext() {
        return current < aggregate.size();
    }

    @Override
    public T next() {
        if (hasNext()) {
            return aggregate.get(current++);
        }
        throw new NoSuchElementException();
    }

    @Override
    public void remove() {
        // 实现删除逻辑
    }
}

6.2.4 🎯 实际应用示例

typescript 复制代码 
// 书类
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;
    }

    @Override
    public 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();
    }

    @Override
    public 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;
    }

    @Override
    public boolean hasNext() {
        return index < bookShelf.getLength();
    }

    @Override
    public Book next() {
        if (hasNext()) {
            return bookShelf.getBookAt(index++);
        }
        throw new NoSuchElementException();
    }

    @Override
    public void remove() {
        // 实现删除逻辑
    }
}

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

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

🏗️ 责任链模式UML类图

7.1 🎭 什么是责任链模式？

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

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

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

7.2 🛠️ 责任链模式的实现

7.2.1 🏗️ 基本结构

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

核心组件：

  • Handler（处理器） ：定义处理请求的接口
  • ConcreteHandler（具体处理器） ：实现处理器接口
  • Client（客户端） ：发起请求的对象

7.2.2 🚀 多种实现方式

实现方式 特点 推荐度
纯责任链 请求必须被处理 ⭐⭐⭐⭐
不纯责任链 请求可能不被处理 ⭐⭐⭐
动态责任链 运行时动态构建链 ⭐⭐⭐⭐⭐

7.2.1 ⛓️ 纯责任链实现

java 复制代码 
// 纯责任链：请求必须被处理
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 {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public void handleRequest(int request) {
        System.out.println("默认处理器处理请求: " + request);
    }
}

不纯责任链实现：

kotlin 复制代码 
// 不纯责任链：请求可能不被处理
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 {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public 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;
        }
    }
}

动态责任链实现：

typescript 复制代码 
// 动态责任链：运行时动态构建链
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;

    @Override
    public 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;
        }
    }

    @Override
    public void setNext(DynamicHandler next) {
        this.next = next;
    }

    @Override
    public DynamicHandler getNext() {
        return next;
    }
}

public class AuthorizationHandler implements DynamicHandler {
    private DynamicHandler next;

    @Override
    public 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;
        }
    }

    @Override
    public void setNext(DynamicHandler next) {
        this.next = next;
    }

    @Override
    public DynamicHandler getNext() {
        return next;
    }
}

public class LoggingHandler implements DynamicHandler {
    private DynamicHandler next;

    @Override
    public 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;
    }

    @Override
    public void setNext(DynamicHandler next) {
        this.next = next;
    }

    @Override
    public DynamicHandler getNext() {
        return next;
    }
}

public class BusinessHandler implements DynamicHandler {
    private DynamicHandler next;

    @Override
    public 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;
        }
    }

    @Override
    public void setNext(DynamicHandler next) {
        this.next = next;
    }

    @Override
    public 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 🎯 标准实现示例

java 复制代码 
// 处理器抽象类 - 定义处理请求的接口
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 {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public 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 🎯 实际应用示例

typescript 复制代码 
// 请假请求
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);
    }

    @Override
    public 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);
    }

    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getLeaveDays() <= 7) {
            System.out.println("经理 " + name + " 审批员工 " + request.getName() +
                    " 的请假申请，请假天数：" + request.getLeaveDays() + " 天");
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

本文使用 markdown.com.cn 排版

相关推荐
饕餮争锋3 小时前
设计模式笔记_行为型_策略模式
笔记·设计模式·策略模式
易元3 小时前
模式组合应用-桥接模式(一)
后端·设计模式
the sun344 小时前
常见的设计模式（2）单例模式
单例模式·设计模式
是2的10次方啊5 小时前
🕺 行为型设计模式：对象协作的舞蹈家（上）
设计模式
一乐小哥7 小时前
从面试高频到实战落地：单例模式全解析（含 6 种实现 + 避坑指南）
java·设计模式
用户84913717547169 小时前
JustAuth实战系列（第11期）：测试驱动开发 - 质量保证与重构实践
java·设计模式·单元测试
melonbo12 小时前
代理模式C++
c++·设计模式·系统安全·代理模式
我们从未走散12 小时前
设计模式学习笔记-----单例模式
java·笔记·学习·单例模式·设计模式
long31615 小时前
java 工厂方法设计模式 FactoryMethod
java·开发语言·后端·设计模式
热门推荐
01UV安装并设置国内源02Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code032025最新国内服务器可用docker源仓库地址大全（2025年8月更新）04【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）05KGG转MP3工具|非KGM文件|解密音频06全球最强模型Grok4，国内已可免费使用！（附教程）07TRAE Rules 实践：为项目配置 6A 工作流08GPT-5 使用限制与国内升级全攻略（免费 / Plus / Pro）【2025 最新】09蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南