Java设计模式 十四 行为型模式 (Behavioral Patterns)

行为型模式 (Behavioral Patterns)

行为型设计模式 关注于对象之间的通信和职责分配，主要用来优化对象之间的交互 和提高系统的灵活性。这些模式帮助我们在程序中实现对象之间的责任链、请求传递、行为协作等。行为型模式通常描述了对象之间如何通过消息传递来完成某项任务。

以下是一些常见的行为型设计模式：

---

1. 策略模式 (Strategy Pattern)

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。策略模式使得算法的变化独立于使用算法的客户端。

• 意图： 定义一系列算法，将每个算法封装成一个类，且使它们可以互换。
• 应用场景： 需要在多个算法之间进行选择，或者某个类的行为需要在运行时动态切换。

示例：

// 策略接口
public interface Strategy {
    void execute();
}

// 具体策略1
public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Strategy A");
    }
}

// 具体策略2
public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Strategy B");
    }
}

// 上下文类
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Strategy strategyA = new ConcreteStrategyA();
        Strategy strategyB = new ConcreteStrategyB();
        
        Context context = new Context(strategyA);
        context.executeStrategy();  // 输出 Strategy A
        
        context = new Context(strategyB);
        context.executeStrategy();  // 输出 Strategy B
    }
}

---

2. 观察者模式 (Observer Pattern)

观察者模式定义了一种一对多的依赖关系，当一个对象状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。通常用于事件处理系统或订阅/发布模式。

• 意图： 当一个对象的状态变化时，自动通知并更新所有依赖于它的对象。
• 应用场景： 当一个对象的变化需要影响其他对象，且不知道有多少对象需要被更新时。

示例：

// 观察者接口
public interface Observer {
    void update(String message);
}

// 具体观察者1
public class ConcreteObserverA implements Observer {
    @Override
    public void update(String message) {
        System.out.println("Observer A received message: " + message);
    }
}

// 具体观察者2
public class ConcreteObserverB implements Observer {
    @Override
    public void update(String message) {
        System.out.println("Observer B received message: " + message);
    }
}

// 被观察者（主题）接口
public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体被观察者
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

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

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

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

    // 状态变化
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observerA = new ConcreteObserverA();
        Observer observerB = new ConcreteObserverB();
        
        subject.addObserver(observerA);
        subject.addObserver(observerB);
        
        subject.setState("New State");  // Observer A and B will be notified
    }
}

---

3. 责任链模式 (Chain of Responsibility Pattern)

责任链模式通过将请求传递给链中的每个对象，直到有对象处理它。责任链模式让多个对象有机会处理请求，从而避免了请求发送者与接受者之间的耦合。

• 意图： 让多个对象都有机会处理请求，将请求的处理责任链式传递下去，直到某个对象处理它。
• 应用场景： 需要将请求分配给多个处理者时，或者某个请求由多个处理者依次处理的场景。

示例：

// 处理者抽象类
public abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(String request);
}

// 具体处理者1
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("Handler A handles the request");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 具体处理者2
public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("Handler B handles the request");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        
        handlerA.setNextHandler(handlerB);
        
        handlerA.handleRequest("B");  // Handler B handles the request
    }
}

---

4. 命令模式 (Command Pattern)

命令模式将请求封装成对象，从而使我们可以将请求的调用者和请求的接收者解耦。命令模式允许用户将请求的执行操作参数化，使得请求者可以异步执行请求、排队请求、记录请求历史等。

• 意图： 将请求封装成一个对象，使得请求发送者和接收者解耦。
• 应用场景： 需要将请求的发送者与接收者解耦，或者需要将请求存储、撤销等操作。

示例：

// 命令接口
public interface Command {
    void execute();
}

// 具体命令1
public class ConcreteCommandA implements Command {
    private Receiver receiver;

    public ConcreteCommandA(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }
}

// 接收者类
public class Receiver {
    public void action() {
        System.out.println("Receiver is performing an action");
    }
}

// 调用者类
public class Invoker {
    private Command command;

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommandA(receiver);
        Invoker invoker = new Invoker();
        
        invoker.setCommand(command);
        invoker.invoke();  // Output: Receiver is performing an action
    }
}

---

5. 状态模式 (State Pattern)

状态模式允许一个对象在其内部状态改变时，改变其行为。对象看起来好像修改了其类。状态模式通常用于处理有多个状态、且根据不同状态来执行不同行为的场景。

• 意图： 允许对象在状态改变时，改变其行为。
• 应用场景： 对象的行为依赖于其状态，且该状态会在运行时改变。

示例：

// 状态接口
public interface State {
    void handleRequest();
}

// 具体状态1
public class ConcreteStateA implements State {
    @Override
    public void handleRequest() {
        System.out.println("State A is handling the request");
    }
}

// 具体状态2
public class ConcreteStateB implements State {
    @Override
    public void handleRequest() {
        System.out.println("State B is handling the request");
    }
}

// 上下文类
public class Context {
    private State state;

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

    public void request() {
        state.handleRequest();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        
        State stateA = new ConcreteStateA();
        context.setState(stateA);
        context.request();  // Output: State A is handling the request
        
        State stateB = new ConcreteStateB();
        context.setState(stateB);
        context.request();  // Output: State B is handling the request
    }
}

---

6. 总结

行为型设计模式主要关注于对象之间的交互和责任分配。