设计模式：行为型（Behavioral）

责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它用于将请求的发送者和接收者解耦，从而可以让多个对象都有机会处理请求，形成一条处理请求的责任链。在责任链模式中，每个处理者对象都可以处理请求，如果当前处理者不能处理请求，则将请求传递给下一个处理者，直到有一个处理者能够处理请求或者请求到达链的末端。

责任链模式主要解决的问题是在一个对象链中，解耦请求的发送者和接收者，使得多个对象都有机会处理请求，并且可以动态地改变请求的处理顺序。责任链模式可以避免将请求的处理逻辑硬编码在一个对象中，使得代码更加灵活、可扩展和可维护。

责任链模式的核心组件包括抽象处理者（Handler）、具体处理者（ConcreteHandler）和客户端（Client）三部分。抽象处理者定义了处理请求的接口和责任链的下一个处理者的引用，具体处理者实现了抽象处理者的接口并负责处理请求，客户端创建责任链并将请求发送给第一个处理者。

以下是一个简单的责任链模式的例子，假设有三个处理者分别用于处理低级、中级和高级的请求：

// 抽象处理者
abstract class Handler {
    protected Handler nextHandler; // 下一个处理者

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

    public abstract void handleRequest(int level);
}

// 具体处理者
class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level <= 10) {
            System.out.println("ConcreteHandler1处理了请求");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level);
        }
    }
}

class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level > 10 && level <= 20) {
            System.out.println("ConcreteHandler2处理了请求");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level);
        }
    }
}

class ConcreteHandler3 extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level > 20) {
            System.out.println("ConcreteHandler3处理了请求");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level);
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        // 发送请求
        handler1.handleRequest(5);
        handler1.handleRequest(15);
        handler1.handleRequest(25);
    }
}

在上面的例子中，三个具体处理者分别处理了不同范围的请求，如果一个处理者无法处理请求，它会将请求传递给下一个处理者，直到有一个处理者能够处理请求或者请求到达责任链的末端。

在这个例子中，ConcreteHandler1处理低级的请求（level <= 10），ConcreteHandler2处理中级的请求（10 < level <= 20），ConcreteHandler3处理高级的请求（level > 20）。客户端通过设置处理者的nextHandler形成了一条责任链，并通过调用handleRequest方法发送请求到责任链的起始处，从而实现了请求的处理。

责任链模式在实际应用中可以用于处理请求的多级处理场景，例如在Web应用中的请求过滤器链、日志记录链、权限验证链等场景中都可以使用责任链模式。它可以帮助将处理逻辑解耦，使得系统更加灵活、可扩展和易于维护。

命令模式（Command Pattern）

命令模式是一种行为型设计模式，用于将请求发送者和请求接收者解耦，将请求封装成一个独立的对象，从而允许请求的发送者在不知道具体请求接收者的情况下，通过调用请求对象来间接地执行请求。

命令模式包含以下角色：

1. Command（命令）：定义了执行请求的接口，通常包含一个execute()方法，用于执行具体的请求。

2. ConcreteCommand（具体命令）：实现了Command接口，负责实现具体的请求逻辑，并持有一个接收者对象，用于执行具体的操作。

3. Receiver（接收者）：负责具体的请求处理逻辑，实现了请求的实际执行。

4. Invoker（调用者）：负责调用命令对象来执行请求，持有命令对象的引用。

5. Client（客户端）：负责创建具体的命令对象并设置其接收者，同时将命令对象传递给调用者。

命令模式的核心思想是将请求封装成一个对象，从而实现请求发送者和请求接收者的解耦，使得请求的发送者只需要与抽象的命令接口进行交互，而不需要了解具体的请求接收者和其处理逻辑。这样可以实现请求的参数化和动态化，提高系统的灵活性和可维护性。

一个简单的命令模式的例子是电视遥控器，遥控器上的按钮相当于请求发送者，遥控器的每个按钮对应一个具体的命令对象，命令对象负责封装具体的操作（例如打开电视、关闭电视、切换频道等）和接收者（电视对象），遥控器持有命令对象的引用并通过调用命令对象的execute()方法来间接地执行具体的操作。这样，遥控器和电视之间解耦，遥控器不需要直接调用电视对象的方法来控制电视的操作，而是通过命令对象来间接地执行。

// Command（命令）：定义了执行文本编辑器操作的接口，例如 Command 接口。
public interface Command {
    void execute();
}

// ConcreteCommand（具体命令）：实现了 Command 接口，负责具体的文本编辑器操作，例如 CopyCommand、CutCommand、PasteCommand 等。
public class CopyCommand implements Command {
    private TextEditor textEditor;

    public CopyCommand(TextEditor textEditor) {
        this.textEditor = textEditor;
    }

    @Override
    public void execute() {
        textEditor.copy();
    }
}

public class CutCommand implements Command {
    private TextEditor textEditor;

    public CutCommand(TextEditor textEditor) {
        this.textEditor = textEditor;
    }

    @Override
    public void execute() {
        textEditor.cut();
    }
}

public class PasteCommand implements Command {
    private TextEditor textEditor;

    public PasteCommand(TextEditor textEditor) {
        this.textEditor = textEditor;
    }

    @Override
    public void execute() {
        textEditor.paste();
    }
}

// Receiver（接收者）：负责实际执行文本编辑器操作的类，例如 TextEditor 类。
public class TextEditor {
    public void copy() {
        System.out.println("执行复制操作");
    }

    public void cut() {
        System.out.println("执行剪切操作");
    }

    public void paste() {
        System.out.println("执行粘贴操作");
    }
}

// Invoker（调用者）：负责调用命令对象来执行请求的类，例如 TextEditorInvoker 类。
public class TextEditorInvoker {
    private Command command;

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

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

// Client（客户端）：负责创建具体的命令对象并设置其接收者，同时将命令对象传递给调用者，例如 Client 类。
public class Client {
    public static void main(String[] args) {
        // 创建接收者
        TextEditor textEditor = new TextEditor();

        // 创建具体命令对象并设置其接收者
        Command copyCommand = new CopyCommand(textEditor);
        Command cutCommand = new CutCommand(textEditor);
        Command pasteCommand = new PasteCommand(textEditor);

        // 创建调用者并设置命令对象
        TextEditorInvoker invoker = new TextEditorInvoker();
        invoker.setCommand(copyCommand);
        invoker.executeCommand();

        invoker.setCommand(cutCommand);
        invoker.executeCommand();

        invoker.setCommand(pasteCommand);
        invoker.executeCommand();
    }
}

迭代器模式（Iterator Pattern）

迭代器模式（Iterator Pattern）是一种行为型设计模式，它提供一种方法来遍历集合对象中的元素，而不需要暴露集合的内部结构。通过使用迭代器模式，可以让客户端在不了解集合内部结构的情况下，遍历集合中的元素。

迭代器模式的主要角色包括：

1. 抽象迭代器（Iterator）：定义了访问和遍历集合中元素的接口，包括 hasNext() 方法判断是否还有下一个元素，和 next() 方法返回下一个元素。

2. 具体迭代器（Concrete Iterator）：实现了抽象迭代器接口，负责实现对具体集合的遍历逻辑。

3. 抽象集合（Aggregate）：定义了集合对象的接口，包括创建迭代器的方法 createIterator()。

4. 具体集合（Concrete Aggregate）：实现了抽象集合接口，负责创建具体迭代器对象，实现对集合的遍历。

迭代器模式的核心思想是将遍历集合的责任封装到迭代器对象中，从而实现了集合和遍历算法的解耦。客户端只需要通过迭代器对象来访问集合中的元素，而不需要关心集合的内部结构。

以下是一个简单的迭代器模式的示例，假设有一个存储了字符串的集合对象，可以使用迭代器模式来遍历并访问这些字符串：

// 抽象迭代器
interface Iterator {
    boolean hasNext();
    String next();
}

// 具体迭代器
class StringIterator implements Iterator {
    private String[] strings;
    private int index;

    public StringIterator(String[] strings) {
        this.strings = strings;
        this.index = 0;
    }

    @Override
    public boolean hasNext() {
        return index < strings.length;
    }

    @Override
    public String next() {
        if (hasNext()) {
            return strings[index++];
        }
        return null;
    }
}

// 抽象集合
interface Aggregate {
    Iterator createIterator();
}

// 具体集合
class StringCollection implements Aggregate {
    private String[] strings;

    public StringCollection(String[] strings) {
        this.strings = strings;
    }

    @Override
    public Iterator createIterator() {
        return new StringIterator(strings);
    }
}

 为什么使用迭代器遍历元素？

1. 封装集合内部结构：使用迭代器模式可以将集合的内部结构封装起来，使客户端无需了解集合的实现细节，只需要通过迭代器对象进行遍历操作。

2. 统一遍历接口：迭代器模式定义了统一的遍历接口，包括 hasNext() 和 next() 方法，使得客户端在遍历不同类型的集合时可以使用相同的接口，不需要针对不同的集合类型编写不同的遍历逻辑。

3. 简化客户端代码：使用迭代器模式可以简化客户端的代码，避免了显式的使用索引或者循环来遍历集合，提供了一种更加简洁和直观的方式来访问集合中的元素。

4. 支持多种遍历方式：迭代器模式可以实现多种不同的遍历方式，例如顺序遍历、逆序遍历、跳跃遍历等，而且可以在运行时动态地切换遍历方式，从而灵活地满足不同的需求。

中介者模式（Mediator Pattern）

中介者模式（Mediator Pattern）是一种行为型设计模式，用于减少多个对象之间的直接依赖关系，通过引入一个中介者对象来协调和管理这些对象之间的通信和交互。中介者模式可以帮助对象之间的解耦，从而降低系统的复杂性。

中介者模式的核心思想是将对象之间的交互逻辑封装到中介者对象中，使得各个对象只需要与中介者对象进行通信，而不需要直接与其他对象通信。这样可以避免对象之间的紧耦合关系，使得系统更加灵活、可扩展和易于维护。

中介者模式通常包含以下几个角色：

1. 中介者（Mediator）：负责协调和管理各个对象之间的通信和交互。通常包含一些公共方法，用于接收和发送消息，并根据消息的内容和类型来决定如何处理。

2. 同事类（Colleague）：包含一些业务逻辑，需要与其他同事类进行通信和交互。各个同事类之间不直接通信，而是通过中介者来进行间接通信。

中介者模式的优点包括：

1. 减少了对象之间的直接依赖关系，使得系统更加灵活和可扩展。

2. 将交互逻辑封装到中介者对象中，使得系统的结构更加清晰，易于维护和理解。

3. 可以集中管理和控制对象之间的通信和交互，提供了一种集中式的方式来处理复杂的交互逻辑。

// 中介者接口
public interface ChatRoomMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

// 具体中介者
public class ChatRoom implements ChatRoomMediator {
    private List<User> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            if (u != user) {
                u.receiveMessage(message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
    }
}

// 同事类
public class User {
    private String name;
    private ChatRoomMediator mediator;

    public User(String name, ChatRoomMediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
        System.out.println(name + " sends message: " + message);
        mediator.sendMessage(message, this);
    }

    public void receiveMessage(String message) {
        System.out.println(name + " receives message: " + message);
    }
}

// 客户端使用示例
public class Client {
    public static void main(String[] args) {
        ChatRoomMediator mediator = new ChatRoom();
        User user1 = new User("User1", mediator);
        User user2 = new User("User2", mediator);
        User user3 = new User("User3", mediator);

        mediator.addUser(user1);
        mediator.addUser(user2);
        mediator.addUser(user3);

        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi, User1!");
    }
}

观察者模式（Observer Pattern）

观察者模式（Observer Pattern）是一种行为型设计模式，用于在对象之间建立一种一对多的依赖关系，当一个对象的状态发生变化时，其依赖的多个对象都会得到通知并自动更新。

观察者模式包含以下几个角色：

1. Subject（主题）：被观察者，它是一个抽象类或接口，定义了被观察者的一些基本方法，如添加、删除和通知观察者等。

2. ConcreteSubject（具体主题）：具体的被观察者实现类，它维护着一组观察者对象，并在状态发生变化时通知观察者。

3. Observer（观察者）：观察者，它是一个抽象类或接口，定义了观察者的一些基本方法，如更新状态等。

4. ConcreteObserver（具体观察者）：具体的观察者实现类，它实现了观察者的更新方法，以便在接收到被观察者通知时进行相应的处理。

观察者模式的核心思想是通过抽象的主题（被观察者）和观察者之间的关联关系，实现了对象之间的松耦合，使得主题和观察者可以独立地演化和扩展，而不会相互影响。当主题的状态发生变化时，会自动通知所有的观察者进行更新，从而实现了对象之间的一对多依赖关系。

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

// 主题（被观察者）
interface Subject {
    void registerObserver(Observer observer); // 注册观察者
    void unregisterObserver(Observer observer); // 取消注册观察者
    void notifyObservers(String news); // 通知观察者
}

// 观察者
interface Observer {
    void update(String news); // 更新方法
}

// 具体主题（具体被观察者）
class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String news;

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

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

    @Override
    public void notifyObservers(String news) {
        this.news = news;
        for (Observer observer : observers) {
            observer.update(news);
        }
    }
}

// 具体观察者
class NewsSubscriber implements Observer {
    private String name;

    public NewsSubscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(String news) {
        System.out.println(name + " 收到了新闻：" + news);
    }
}

public class ObserverPatternExample {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher(); // 创建新闻发布者

        Observer subscriber1 = new NewsSubscriber("Subscriber 1"); // 创建订阅者1
        Observer subscriber2 = new NewsSubscriber("Subscriber 2"); // 创建订阅者2

        publisher.registerObserver(subscriber1); // 注册订阅者1
        publisher.registerObserver(subscriber2); // 注册订阅者2

        publisher.notifyObservers("Breaking News: COVID-19 Vaccine Released!"); // 发布新闻

        publisher.unregisterObserver(subscriber1); // 取消注册订阅者1

        publisher.notifyObservers("Latest News: Economic Growth Forecast Revised!"); // 发布新闻

    }
}

 

状态模式（State Pattern）

状态模式（State Pattern）是一种行为型设计模式，用于通过将对象的状态封装成不同的状态对象，并在对象的状态发生变化时，动态地改变对象的行为。状态模式将对象的行为和状态解耦，使得对象可以根据不同的状态进行不同的行为处理，从而实现状态的变化对对象行为的灵活控制。

状态模式的核心思想是将对象的状态抽象成一个状态接口（或者抽象类），然后将不同的状态实现为具体的状态类，这些状态类可以根据具体的业务需求来进行扩展和修改。对象持有一个当前状态对象的引用，通过该状态对象来处理不同的行为。

状态模式通常包含以下几个角色：

1. 上下文（Context）：它是持有状态的对象，负责管理状态对象的切换和调用相应的行为。通常包含一个对抽象状态的引用，以及一个对客户端的请求的处理方法。

2. 抽象状态（State）：定义了状态的接口，通常包含了处理请求的方法。在状态模式中，抽象状态可以是接口或者抽象类，具体的状态类需要实现这些方法。

3. 具体状态（Concrete State）：实现了抽象状态定义的接口，负责具体的状态行为处理。具体状态类通常会包含对环境对象的引用，用于在处理请求时切换状态或者调用环境对象的方法。

状态模式通过将对象的状态封装成状态对象，使得状态的变化对对象行为的影响局限于具体的状态类，而不会影响到其他状态类。这样可以实现状态的变化对对象行为的灵活控制，从而提高系统的扩展性和可维护性。状态模式通常适用于对象的行为随状态的变化而改变的场景，例如订单状态、用户登录状态等。

假设我们有一个电梯系统，其中电梯可以处于三种状态：停止状态、运行状态和故障状态。在不同的状态下，电梯有不同的行为。我们可以使用状态模式来实现这个电梯系统。

// 抽象状态接口
public interface ElevatorState {
    void open();
    void close();
    void run();
    void stop();
}

// 具体状态类 - 停止状态
public class StopState implements ElevatorState {
    // 实现停止状态下的行为
    // ...
}

// 具体状态类 - 运行状态
public class RunState implements ElevatorState {
    // 实现运行状态下的行为
    // ...
}

// 具体状态类 - 故障状态
public class FaultState implements ElevatorState {
    // 实现故障状态下的行为
    // ...
}

public class ElevatorContext {
    private ElevatorState currentState; // 当前状态

    // 设置当前状态
    public void setCurrentState(ElevatorState state) {
        this.currentState = state;
    }

    // 处理开门请求
    public void open() {
        currentState.open();
    }

    // 处理关门请求
    public void close() {
        currentState.close();
    }

    // 处理运行请求
    public void run() {
        currentState.run();
    }

    // 处理停止请求
    public void stop() {
        currentState.stop();
    }
}

public class Client {
    public static void main(String[] args) {
        ElevatorContext context = new ElevatorContext(); // 创建电梯环境对象
        context.setCurrentState(new StopState()); // 初始状态为停止状态

        // 处理电梯请求
        context.open(); // 开门
        context.close(); // 关门
        context.run(); // 运行
        context.stop(); // 停止
    }
}

策略模式（Strategy Pattern）

策略模式（Strategy Pattern）是一种行为型设计模式，它允许在运行时动态地选择算法或行为，从而使对象能够根据不同的情境或条件选择不同的策略来完成任务，而不需要在代码中硬编码特定的算法或行为。

策略模式由三个主要角色组成：

1. 上下文（Context）：负责与客户端进行交互，它持有一个策略对象，并通过策略对象来执行具体的行为。

2. 抽象策略（Strategy）：定义一个共同的接口或抽象类，用于表示不同策略的通用行为。

3. 具体策略（Concrete Strategy）：实现了抽象策略定义的接口或抽象类，具体实现了策略模式中定义的不同算法或行为。

一个常见的策略模式的例子是在电商系统中的商品促销活动，其中不同的促销活动可以视为不同的策略，可以根据用户选择或系统配置来动态选择不同的促销策略进行应用。

// 抽象策略接口 - 商品促销策略
public interface PromotionStrategy {
    void applyPromotion(double price);
}

// 具体策略类 - 满减促销策略
public class FullDiscountPromotionStrategy implements PromotionStrategy {
    @Override
    public void applyPromotion(double price) {
        System.out.println("满减促销活动：原价 " + price + " 元，满100元减20元，优惠后 " + (price - 20) + " 元");
    }
}

// 具体策略类 - 折扣促销策略
public class DiscountPromotionStrategy implements PromotionStrategy {
    @Override
    public void applyPromotion(double price) {
        System.out.println("折扣促销活动：原价 " + price + " 元，8折优惠后 " + (price * 0.8) + " 元");
    }
}

// 上下文类 - 商品
public class Product {
    private double price; // 商品价格
    private PromotionStrategy promotionStrategy; // 持有一个促销策略对象

    // 设置商品价格
    public void setPrice(double price) {
        this.price = price;
    }

    // 设置促销策略对象
    public void setPromotionStrategy(PromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }

    // 应用促销策略
    public void applyPromotion() {
        promotionStrategy.applyPromotion(price);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product product = new Product(); // 创建商品对象
        product.setPrice(120.0); // 设置商品价格

        // 使用满减促销策略
        PromotionStrategy fullDiscountPromotion = new FullDiscountPromotionStrategy();
        product.setPromotionStrategy(fullDiscountPromotion);
        product.applyPromotion(); // 应用促销策略

        // 使用折扣促销策略
        PromotionStrategy discountPromotion = new DiscountPromotionStrategy();
        product.setPromotionStrategy(discountPromotion);
        product.applyPromotion(); // 应用促销策略
    }
}

模板模式（Template Pattern）

模板模式（Template Pattern）是一种行为型设计模式，用于定义一个操作的算法骨架，将一些步骤延迟到子类中实现，从而使子类可以在不改变算法骨架的情况下重新定义某些步骤。

模板模式的核心思想是通过抽象类或接口定义一个模板（Template），其中包含了一个算法的骨架，但留下了一些步骤的实现细节交由子类来实现，从而使得子类可以根据需要灵活地实现这些细节，而不改变算法骨架。

模板模式有以下几个关键角色：

1. 抽象模板（Abstract Template）：定义一个模板方法，其中包含了算法的骨架，可以包含一些具体方法和抽象方法，抽象方法用于留给子类实现。
2. 具体模板（Concrete Template）：实现抽象模板中的抽象方法，完成算法的具体步骤。
3. 客户端（Client）：使用模板方法来调用算法，可以通过调用抽象模板中的模板方法来执行算法，不需要关心算法的具体实现，只需要关心算法的调用和结果。

// 抽象模板 - 咖啡制作
public abstract class CoffeeMaker {
    // 制作咖啡
    public final void makeCoffee() {
        boilWater();
        brewCoffee();
        pourInCup();
        addCondiments();
        System.out.println("咖啡制作完成！");
    }

    // 烧水
    private void boilWater() {
        System.out.println("烧水...");
    }

    // 冲泡咖啡
    protected abstract void brewCoffee();

    // 倒入杯中
    private void pourInCup() {
        System.out.println("倒入杯中...");
    }

    // 加入调料
    protected abstract void addCondiments();
}

// 具体模板 - 拿铁咖啡
public class LatteCoffeeMaker extends CoffeeMaker {
    @Override
    protected void brewCoffee() {
        System.out.println("冲泡浓缩咖啡...");
    }

    @Override
    protected void addCondiments() {
        System.out.println("加入牛奶和糖...");
    }
}

// 具体模板 - 美式咖啡
public class AmericanoCoffeeMaker extends CoffeeMaker {
    @Override
    protected void brewCoffee() {
        System.out.println("冲泡黑咖啡...");
    }

    @Override
    protected void addCondiments() {
        // 不加入调料
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        CoffeeMaker latteCoffeeMaker = new LatteCoffeeMaker();
        latteCoffeeMaker.makeCoffee(); // 制作拿铁咖
        // 输出结果：
        // 烧水...
        // 冲泡浓缩咖啡...
        // 倒入杯中...
        // 加入牛奶和糖...
        // 咖啡制作完成！

        CoffeeMaker americanoCoffeeMaker = new AmericanoCoffeeMaker();
        americanoCoffeeMaker.makeCoffee(); // 制作美式咖啡

        // 输出结果：
        // 烧水...
        // 冲泡黑咖啡...
        // 倒入杯中...
        // 咖啡制作完成！
    }
}

备忘录模式（Memento Pattern）

备忘录模式（Memento Pattern）是一种行为型设计模式，它用于在不破坏封装性的前提下保存和恢复对象的内部状态。备忘录模式通过将对象的状态保存到备忘录对象中，从而允许在后续的时刻将对象恢复到之前保存的状态。

备忘录模式的核心角色包括三个：

1. 发起人（Originator）：负责创建一个备忘录对象，并可以使用备忘录对象来恢复自己的状态。
2. 备忘录（Memento）：负责存储发起人的状态，并可以提供发起人访问和恢复状态的接口。
3. 管理者（Caretaker）：负责管理备忘录对象，可以将备忘录对象保存起来或者从中恢复状态。

备忘录模式的核心思想是将对象的状态进行备份，并通过备忘录对象来保存状态。这样可以在需要的时候将对象的状态恢复到之前的某个状态，从而实现对象状态的撤销或者回滚功能。

一个常见的备忘录模式的例子是文本编辑器的撤销/恢复功能。在一个文本编辑器中，用户可以进行文本的编辑、删除、插入等操作，同时可以通过撤销/恢复按钮来撤销上一步或者恢复之前撤销的操作。这就涉及到了对象状态的保存和恢复，可以通过备忘录模式来实现。

// 备忘录类，保存文本编辑器的状态
class TextEditorMemento {
    private String text;

    public TextEditorMemento(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }
}

// 发起人类，文本编辑器类
class TextEditor {
    private String text;

    public void setText(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    // 创建备忘录，保存当前状态
    public TextEditorMemento createMemento() {
        return new TextEditorMemento(text);
    }

    // 恢复状态
    public void restoreMemento(TextEditorMemento memento) {
        this.text = memento.getText();
    }
}

// 管理者类，负责管理备忘录对象
class Caretaker {
    private TextEditorMemento memento;

    public TextEditorMemento getMemento() {
        return memento;
    }

    public void setMemento(TextEditorMemento memento) {
        this.memento = memento;
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        TextEditor textEditor = new TextEditor();
        Caretaker caretaker = new Caretaker();

        textEditor.setText("Hello, world!"); // 设置初始文本
        System.out.println("Current Text: " + textEditor.getText()); // 输出当前文本

        caretaker.setMemento(textEditor.createMemento()); // 创建备忘录并保存到管理者对象

        textEditor.setText("Hello, design patterns!"); // 修改文本
        System.out.println("Modified Text: " + textEditor.getText()); // 输出修改后的文本

        textEditor.restoreMemento(caretaker.getMemento()); // 恢复文本编辑器的状态
        System.out.println("Restored Text: " + textEditor.getText()); // 输出恢复后的文本
    }
}

访问者模式（Visitor Pattern）

访问者模式（Visitor Pattern）是一种行为型设计模式，用于将算法与数据结构分离，使得可以在不修改数据结构的情况下定义新的操作。访问者模式通过将对数据结构的操作封装到独立的访问者类中，实现了对数据结构的操作与数据结构本身的解耦。

访问者模式中的主要角色包括：

1. 抽象访问者（Visitor）：定义了访问者的接口，包括了访问者对于各种元素类型的访问方法。具体的访问者类需要实现这些接口，从而可以对元素进行具体的操作。
2. 具体访问者（Concrete Visitor）：实现了抽象访问者接口，对元素进行具体的操作。
3. 抽象元素（Element）：定义了元素的接口，包括了接受访问者访问的方法。
4. 具体元素（Concrete Element）：实现了抽象元素接口，定义了具体的元素类型，并实现了接受访问者访问的方法。
5. 对象结构（Object Structure）：包含了一组元素对象，并且提供了让访问者访问元素的接口。

访问者模式的核心思想是将对数据结构的操作从数据结构本身中分离出来，使得可以根据需要定义新的操作，而不需要修改数据结构的代码。这种分离可以使得系统更加灵活和可扩展，尤其在需要对数据结构进行多种不同操作的情况下，访问者模式能够有效地管理这些操作。

// 抽象元素接口：展品
interface Exhibit {
    void accept(Visitor visitor);
}

// 具体元素类：绘画
class Painting implements Exhibit {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitPainting(this);
    }
}

// 具体元素类：雕塑
class Sculpture implements Exhibit {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitSculpture(this);
    }
}

// 具体元素类：文物
class Artifact implements Exhibit {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitArtifact(this);
    }
}

// 抽象访问者接口：导览员
interface Visitor {
    void visitPainting(Painting painting);
    void visitSculpture(Sculpture sculpture);
    void visitArtifact(Artifact artifact);
}

// 具体访问者类：具体导览员
class TourGuide implements Visitor {
    @Override
    public void visitPainting(Painting painting) {
        System.out.println("导览员正在介绍绘画：" + painting);
    }

    @Override
    public void visitSculpture(Sculpture sculpture) {
        System.out.println("导览员正在介绍雕塑：" + sculpture);
    }

    @Override
    public void visitArtifact(Artifact artifact) {
        System.out.println("导览员正在介绍文物：" + artifact);
    }
}

// 对象结构类：展厅
class ExhibitionHall {
    private List<Exhibit> exhibits = new ArrayList<>();

    // 添加展品
    public void addExhibit(Exhibit exhibit) {
        exhibits.add(exhibit);
    }

    // 移除展品
    public void removeExhibit(Exhibit exhibit) {
        exhibits.remove(exhibit);
    }

    // 接受导览员访问
    public void accept(Visitor visitor) {
        for (Exhibit exhibit : exhibits) {
            exhibit.accept(visitor);
        }
    }
}

public class VisitorPatternExample {
    public static void main(String[] args) {
        // 创建具体展品对象
        Painting painting = new Painting();
        Sculpture sculpture = new Sculpture();
        Artifact artifact = new Artifact();

        // 创建导览员对象
        TourGuide tourGuide = new TourGuide();

        // 创建展厅对象
        ExhibitionHall exhibitionHall = new ExhibitionHall();
        exhibitionHall.addExhibit(painting);
        exhibitionHall.addExhibit(sculpture);
        exhibitionHall.addExhibit(artifact);

        // 接受导览员访问
        exhibitionHall.accept(tourGuide);
    }
}

解释器模式（Interpreter Pattern）

解释器模式（Interpreter Pattern）是一种行为型设计模式，它用于定义一种语言的文法规则，并通过解释器来解析和执行语言中的表达式。该模式通常用于处理复杂的语法分析和解释任务，可以将一个语言的语法规则表示为一个类的层次结构，并通过解释器来实现对语言表达式的解释和执行。

解释器模式包含以下几个角色：

1. 抽象表达式（Abstract Expression）：定义了一个抽象的解释器接口，包含了解释器的抽象方法，用于对表达式进行解释和执行。
2. 终结符表达式（Terminal Expression）：实现了抽象表达式接口的终结符表达式类，表示语言中的终结符，不再包含子表达式。
3. 非终结符表达式（Non-terminal Expression）：实现了抽象表达式接口的非终结符表达式类，表示语言中的非终结符，包含了一个或多个子表达式，并通过解释器对子表达式进行解释和执行。
4. 上下文（Context）：包含了待解释的语言表达式，通常包含了一些全局信息，供解释器使用。
5. 客户端（Client）：创建和配置具体的表达式对象，并将上下文传递给解释器进行解释和执行。

解释器模式的基本工作流程如下：

1. 客户端创建和配置具体的表达式对象，构建语言表达式的抽象语法树。
2. 客户端将上下文传递给解释器。
3. 解释器对抽象语法树进行解释和执行，递归地对子表达式进行解释和执行，直到所有的表达式都被解释和执行完毕，得到最终的结果。

// 抽象表达式接口
interface Expression {
    boolean interpret(String context);
}

// 终结符表达式实现类
class TerminalExpression implements Expression {
    private String pattern;

    public TerminalExpression(String pattern) {
        this.pattern = pattern;
    }

    @Override
    public boolean interpret(String context) {
        return context.contains(pattern);
    }
}

// 非终结符表达式实现类
class OrExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public OrExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public boolean interpret(String context) {
        return expression1.interpret(context) || expression2.interpret(context);
    }
}

// 非终结符表达式实现类
class AndExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public AndExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public boolean interpret(String context) {
        return expression1.interpret(context) && expression2.interpret(context);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 构建正则表达式的语法树
        Expression expression1 = new TerminalExpression("apple");
        Expression expression2 = new TerminalExpression("banana");
        Expression expression3 = new TerminalExpression("cherry");

        Expression orExpression = new OrExpression(expression1, expression2); // apple or banana
        Expression andExpression = new AndExpression(orExpression, expression3); // (apple or banana) and cherry

        // 使用解释器进行匹配
        String input1 = "I like apple and cherry";
        String input2 = "I prefer banana";
        String input3 = "I love cherry";
        String input4 = "I enjoy orange";

        System.out.println(andExpression.interpret(input1)); // 输出 true
        System.out.println(andExpression.interpret(input2)); // 输出 false
        System.out.println(andExpression.interpret(input3)); // 输出 false
        System.out.println(andExpression.interpret(input4)); // 输出 false
    }
}