编辑“︁Java行为型模式”︁（章节）

= Java行为型模式 =

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

== 概述 ==
行为型模式主要分为以下几类：
* '''责任链模式'''（Chain of Responsibility）
* '''命令模式'''（Command）
* '''解释器模式'''（Interpreter）
* '''迭代器模式'''（Iterator）
* '''中介者模式'''（Mediator）
* '''备忘录模式'''（Memento）
* '''观察者模式'''（Observer）
* '''状态模式'''（State）
* '''策略模式'''（Strategy）
* '''模板方法模式'''（Template Method）
* '''访问者模式'''（Visitor）

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

== 常见行为型模式详解 ==

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

==== 代码示例 ====
<syntaxhighlight lang="java">
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
    }
}
</syntaxhighlight>

==== 实际应用 ====
观察者模式广泛应用于事件处理系统，如：
* GUI框架中的按钮点击事件监听。
* 发布-订阅系统（如消息队列）。

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

==== 代码示例 ====
<syntaxhighlight lang="java">
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
    }
}
</syntaxhighlight>

==== 实际应用 ====
策略模式常用于：
* 支付方式的选择（信用卡、PayPal等）。
* 排序算法的动态切换（如快速排序、归并排序）。

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

==== 代码示例 ====
<syntaxhighlight lang="java">
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
    }
}
</syntaxhighlight>

==== 实际应用 ====
状态模式适用于：
* 游戏角色的状态管理（如行走、跳跃、攻击）。
* 工作流引擎中的状态转换。

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

==== 代码示例 ====
<syntaxhighlight lang="java">
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.");
    }
}
</syntaxhighlight>

==== 实际应用 ====
责任链模式适用于：
* 日志记录系统（不同级别的日志由不同处理器处理）。
* 审批流程（如请假审批链）。

== 总结 ==
行为型模式通过优化对象之间的交互，提高了代码的灵活性和可维护性。每种模式都有其适用场景：
* '''观察者模式'''：一对多的依赖关系。
* '''策略模式'''：动态切换算法。
* '''状态模式'''：对象状态影响行为。
* '''责任链模式'''：请求的链式处理。

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

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java设计模式]]