Java行为型模式

Java行为型模式

行为型模式是设计模式的一种类型，它关注对象之间的通信和职责分配，用于优化对象之间的交互方式。在Java中，行为型模式帮助开发者更高效地管理对象的行为，提高代码的可扩展性和可维护性。这些模式通常涉及算法和对象间职责的分配，而不是关注对象的创建或结构。

概述

行为型模式主要分为以下几类：

• 责任链模式（Chain of Responsibility）
• 命令模式（Command）
• 解释器模式（Interpreter）
• 迭代器模式（Iterator）
• 中介者模式（Mediator）
• 备忘录模式（Memento）
• 观察者模式（Observer）
• 状态模式（State）
• 策略模式（Strategy）
• 模板方法模式（Template Method）
• 访问者模式（Visitor）

这些模式通过定义对象之间的通信方式，使代码更加灵活和可复用。

常见行为型模式详解

观察者模式（Observer）

观察者模式定义了一种一对多的依赖关系，当一个对象（被观察者）的状态发生变化时，所有依赖它的对象（观察者）都会自动收到通知并更新。

代码示例

import java.util.ArrayList;
import java.util.List;

// 被观察者（Subject）
class Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

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

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

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

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

// 具体观察者
class BinaryObserver implements Observer {
    private Subject subject;

    public BinaryObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        new BinaryObserver(subject);

        subject.setState(15); // 输出：Binary String: 1111
    }
}

实际应用

观察者模式广泛应用于事件处理系统，如：

• GUI框架中的按钮点击事件监听。
• 发布-订阅系统（如消息队列）。

策略模式（Strategy）

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

代码示例

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card: " + cardNumber);
    }
}

class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal: " + email);
    }
}

class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.setPaymentStrategy(new CreditCardPayment("1234-5678-9012-3456"));
        cart.checkout(100); // 输出：Paid 100 using Credit Card: 1234-5678-9012-3456

        cart.setPaymentStrategy(new PayPalPayment("user@example.com"));
        cart.checkout(200); // 输出：Paid 200 using PayPal: user@example.com
    }
}

实际应用

策略模式常用于：

• 支付方式的选择（信用卡、PayPal等）。
• 排序算法的动态切换（如快速排序、归并排序）。

状态模式（State）

状态模式允许对象在其内部状态改变时改变其行为，看起来像是对象的类发生了变化。

代码示例

interface State {
    void handle(Context context);
}

class StartState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Player is in start state");
        context.setState(this);
    }

    public String toString() {
        return "Start State";
    }
}

class StopState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Player is in stop state");
        context.setState(this);
    }

    public String toString() {
        return "Stop State";
    }
}

class Context {
    private State state;

    public Context() {
        state = null;
    }

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

    public State getState() {
        return state;
    }
}

public class StatePatternDemo {
    public static void main(String[] args) {
        Context context = new Context();

        StartState startState = new StartState();
        startState.handle(context); // 输出：Player is in start state

        StopState stopState = new StopState();
        stopState.handle(context); // 输出：Player is in stop state
    }
}

实际应用

状态模式适用于：

• 游戏角色的状态管理（如行走、跳跃、攻击）。
• 工作流引擎中的状态转换。

责任链模式（Chain of Responsibility）

责任链模式将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。

代码示例

abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;
    protected Logger nextLogger;

    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);
}

class ConsoleLogger extends Logger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Console Logger: " + message);
    }
}

class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error Logger: " + message);
    }
}

public class ChainPatternDemo {
    private static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger consoleLogger = new ConsoleLogger(Logger.INFO);
        errorLogger.setNextLogger(consoleLogger);
        return errorLogger;
    }

    public static void main(String[] args) {
        Logger loggerChain = getChainOfLoggers();
        loggerChain.logMessage(Logger.INFO, "This is an information.");
        loggerChain.logMessage(Logger.ERROR, "This is an error.");
    }
}

实际应用

责任链模式适用于：

• 日志记录系统（不同级别的日志由不同处理器处理）。
• 审批流程（如请假审批链）。

总结

行为型模式通过优化对象之间的交互，提高了代码的灵活性和可维护性。每种模式都有其适用场景：

• 观察者模式：一对多的依赖关系。
• 策略模式：动态切换算法。
• 状态模式：对象状态影响行为。
• 责任链模式：请求的链式处理。

掌握这些模式有助于编写更高效、可扩展的Java代码。