Java 23种设计模式超全详解（三）-16uni

行为型模式（管"怎么干活"的）

13. 责任链模式（Chain of Responsibility）

问题：请求如何接力传递？
生活案例：报销审批链（员工→经理→财务）
核心：处理器链表

abstract class Approver {
    protected Approver next;
    public void setNext(Approver next) { this.next = next; }
    abstract void handle(int amount);
}

class Manager extends Approver {
    void handle(int amount) {
        if (amount < 1000) {
            System.out.println("经理审批");
        } else if (next != null) {
            next.handle(amount); // 传递给下一级
        }
    }
}

14. 命令模式（Command）

问题：如何解耦请求和执行？
生活案例：餐厅订单（点菜→厨师）
核心：封装操作为对象

interface Command {
    void execute();
}

class LightOnCommand implements Command {
    private Light light;
    public void execute() { light.on(); }
}

class RemoteControl {
    private Command command;
    public void press() { command.execute(); }
}

15. 解释器模式（Interpreter）

问题：如何解释特定语法？
生活案例：计算器解析数学表达式
核心：定义语法规则

interface Expression {
    int interpret();
}

class Number implements Expression {
    private int value;
    public int interpret() { return value; }
}

class Add implements Expression {
    private Expression left, right;
    public int interpret() {
        return left.interpret() + right.interpret();
    }
}

16. 迭代器模式（Iterator）

问题：如何统一遍历集合？
生活案例：遥控器切换电视频道
核心：分离集合和遍历

interface Iterator {
    boolean hasNext();
    Object next();
}

class ChannelList implements Iterable {
    private String[] channels = {"CCTV", "Hunan TV"};
    
    public Iterator iterator() {
        return new ChannelIterator();
    }
    
    private class ChannelIterator implements Iterator {
        int index = 0;
        public boolean hasNext() { return index < channels.length; }
        public Object next() { return channels[index++]; }
    }
}

17. 中介者模式（Mediator）

问题：如何减少对象耦合？
生活案例：机场塔台调度飞机
核心：通过中介通信

class ChatRoom {
    public static void showMessage(User user, String msg) {
        System.out.println(user.name + ": " + msg);
    }
}

class User {
    String name;
    public void sendMsg(String msg) {
        ChatRoom.showMessage(this, msg); // 通过聊天室发送
    }
}

18. 备忘录模式（Memento）

问题：如何实现撤销功能？
生活案例：游戏存档
核心：保存对象状态

class Editor {
    private String content;
    
    // 创建存档
    public EditorMemento save() { 
        return new EditorMemento(content); 
    }
    
    // 恢复存档
    public void restore(EditorMemento memento) { 
        content = memento.getContent(); 
    }
}

class EditorMemento {
    private final String content;
    public EditorMemento(String content) { this.content = content; }
    public String getContent() { return content; }
}

19. 观察者模式（Observer）

问题：状态变化如何通知？
生活案例：微信公众号订阅
核心：发布-订阅机制

class NewsPublisher {
    private List<Subscriber> subs = new ArrayList<>();
    
    public void addSub(Subscriber sub) { subs.add(sub); }
    
    public void publish(String news) {
        for (Subscriber sub : subs) {
            sub.update(news); // 通知所有订阅者
        }
    }
}

interface Subscriber {
    void update(String news);
}

20. 状态模式（State）

问题：行为如何随状态改变？
生活案例：红绿灯状态变化
核心：封装状态行为

interface TrafficLightState {
    void handle();
}

class RedLight implements TrafficLightState {
    public void handle() { System.out.println("停车等待"); }
}

class TrafficLight {
    private TrafficLightState state;
    public void change() { state.handle(); }
}

21. 策略模式（Strategy）

问题：如何灵活切换算法？
生活案例：导航选择不同路线
核心：封装算法族

interface RouteStrategy {
    void calculateRoute();
}

class FastestRoute implements RouteStrategy {
    public void calculateRoute() { /* 计算最快路线 */ }
}

class Navigator {
    private RouteStrategy strategy;
    public void setStrategy(RouteStrategy s) { strategy = s; }
    public void navigate() { strategy.calculateRoute(); }
}

22. 模板方法模式（Template Method）

问题：如何固定流程框架？
生活案例：冲泡饮料流程（烧水→冲泡→加料）
核心：定义算法骨架

abstract class Beverage {
    // 模板方法（final防止重写）
    public final void prepare() {
        boilWater();
        brew();
        addCondiments();
    }
    
    abstract void brew(); // 子类实现
    abstract void addCondiments();
    
    void boilWater() { /* 通用步骤 */ }
}

class Coffee extends Beverage {
    void brew() { System.out.println("冲泡咖啡"); }
    void addCondiments() { System.out.println("加糖"); }
}

23. 访问者模式（Visitor）

问题：如何解耦数据结构与操作？
生活案例：医生诊断不同病人
核心：双重分发

interface ComputerPart {
    void accept(Visitor visitor);
}

class Keyboard implements ComputerPart {
    public void accept(Visitor v) { v.visit(this); }
}

interface Visitor {
    void visit(Keyboard keyboard);
}

class RepairVisitor implements Visitor {
    public void visit(Keyboard k) { 
        System.out.println("修理键盘"); 
    }
}

设计模式选择指南（3步法）

创建对象遇到问题？ → 创建型模式
- 需要全局唯一？→ 单例
- 创建过程复杂？→ 建造者
- 需要产品家族？→ 抽象工厂
组织对象结构困难？ → 结构型模式
- 接口不兼容？→ 适配器
- 需动态增功能？→ 装饰器
- 简化复杂系统？→ 外观
对象协作不顺畅？ → 行为型模式
- 状态需要通知？→ 观察者
- 需切换算法？→ 策略
- 分步骤处理？→ 模板方法

目录CONTENT

Java 23种设计模式超全详解（三）