设计模式揭秘：解剖十一种行为型模式，代码实现实例让你醍醐灌顶

走进行为型模式的魅力世界：掌握对象交互的艺术

在软件开发的迷人世界中，设计模式就像璀璨的星光，指引着我们代码的航向。行为型模式作为设计模式家族中不可或缺的一员，凭借其对对象交互的精湛控制，备受程序员的青睐。在这篇文章中，我们将踏上一段探索行为型模式的神奇之旅，了解它们如何赋予我们的代码灵活、可扩展和可维护的非凡魅力。

1. 策略模式：因地制宜，运筹帷幄

策略模式是适应变化的强大武器。它巧妙地将算法或行为与使用它们的类分离，允许你轻松更换算法，而不影响客户端代码。就像在战场上运筹帷幄一样，策略模式让你灵活应变，掌控全局。

示例：

// Interface for different sorting algorithms
interface SortStrategy {
    void sort(int[] arr);
}

// Bubble sort strategy
class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // Implement bubble sort algorithm
    }
}

// Merge sort strategy
class MergeSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // Implement merge sort algorithm
    }
}

// Context class that uses the strategy
class SortingContext {
    private SortStrategy strategy;

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void sort(int[] arr) {
        strategy.sort(arr);
    }
}

2. 观察者模式：千里眼，洞察全局

观察者模式就像千里眼，让对象可以订阅它们感兴趣的事件。当事件发生时，这些对象会自动收到通知，并做出相应的反应。它创造了一种松散耦合且高效的信息传递机制。

示例：

// Interface for observers
interface Observer {
    void update();
}

// Concrete observer class
class ConcreteObserverA implements Observer {
    @Override
    public void update() {
        // React to event
    }
}

// Subject class that manages observers
class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

3. 迭代器模式：漫步容器，游刃有余

迭代器模式就像一位经验丰富的旅行者，可以轻松地遍历容器中的元素。它与容器的具体实现细节无关，让你专注于访问数据本身。代码因此变得简洁优雅，仿佛在容器中漫步，游刃有余。

示例：

// Interface for iterators
interface Iterator<T> {
    boolean hasNext();

    T next();
}

// Concrete iterator class
class ListIterator<T> implements Iterator<T> {
    private List<T> list;
    private int index = 0;

    public ListIterator(List<T> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return index < list.size();
    }

    @Override
    public T next() {
        return list.get(index++);
    }
}

4. 命令模式：一呼百应，弹指间完成任务

命令模式就像一位威严的将军，可以将一组操作封装成一个命令对象。只需发出一个命令，你就可以完成一系列复杂的任务。代码由此变得清晰可控，仿佛一呼百应，弹指间完成任务。

示例：

// Interface for commands
interface Command {
    void execute();
}

// Concrete command class
class TurnOnLightCommand implements Command {
    private Light light;

    public TurnOnLightCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

// Invoker class that executes commands
class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void executeCommand() {
        command.execute();
    }
}

5. 责任链模式：层层递进，逐级解决问题

责任链模式就像一个高效的客服中心，将请求逐级传递给不同的处理者，直到找到合适的处理者为止。它让代码更加灵活健壮，仿佛层层递进，逐级解决问题，直至真相大白。

示例：

// Interface for handlers
interface Handler {
    boolean handleRequest(Request request);
}

// Concrete handler class
class HandlerA implements Handler {
    @Override
    public boolean handleRequest(Request request) {
        // Handle request and return true if handled, false otherwise
    }
}

// Handler chain class that manages handlers
class HandlerChain {
    private List<Handler> handlers = new ArrayList<>();

    public void addHandler(Handler handler) {
        handlers.add(handler);
    }

    public boolean handleRequest(Request request) {
        for (Handler handler : handlers) {
            if (handler.handleRequest(request)) {
                return true;
            }
        }
        return false;
    }
}

6. 备忘录模式：时光倒流，重现昔日风采

备忘录模式就像时光机，可以将对象的状态保存下来，并在需要的时候恢复到该状态。代码因此变得更加灵活可靠，仿佛在时间长河中穿梭，重现昔日风采。

示例：

// Originator class that creates and stores state
class Originator {
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public Memento createMemento() {
        return new Memento(state);
    }

    public void restoreMemento(Memento memento) {
        state = memento.getState();
    }
}

// Memento class that stores state
class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

7. 状态模式：千变万化，游刃有余

状态模式就像一位多面手，可以根据不同的状态做出不同的行为。代码由此变得更加灵活健壮，仿佛在不同状态之间切换自如，游刃有余。

示例：

// Interface for states
interface State {
    void doAction();
}

// Concrete state class
class ConcreteStateA implements State {
    @Override
    public void doAction() {
        // Perform action for state A
    }
}

// Context class that manages states
class Context {
    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public void doAction() {
        state.doAction();
    }
}

8. 访问者模式：洞察本质，抽丝剥茧

访问者模式就像一位经验丰富的侦探，可以访问并操作对象内部的数据，而无需了解对象的具体类型。代码因此变得更加灵活可扩展，仿佛抽丝剥茧，洞察事物的本质。

示例：

// Interface for visitors
interface Visitor {
    void visitElementA(ElementA elementA);

    void visitElementB(ElementB elementB);
}

// Concrete visitor class
class ConcreteVisitor implements Visitor {
    @Override
    public void visitElementA(ElementA elementA) {
        // Visit element A
    }

    @Override
    public void visitElementB(ElementB elementB) {
        // Visit element B
    }
}

// Element class that accepts visitors
class Element {
    public void acceptVisitor(Visitor visitor) {
        visitor.visitElement(this);
    }
}

9. 中介者模式：居中协调，化繁为简

中介者模式就像一位和蔼可亲的调解员，可以协调多个对象之间的交互，使它们之间无需直接通信。代码由此变得更加简洁易懂，仿佛化繁为简，让复杂的问题变得清晰明了。

示例：

// Interface for mediators
interface Mediator {
    void sendRequest(Request request, Colleague colleague);
}

// Concrete mediator class
class ConcreteMediator implements Mediator {
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {