Java三大设计模式

Java设计模式

创建型模式

• 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
• 工厂模式（Factory Pattern）：定义一个创建对象的接口，让子类决定实例化哪一个类。
• 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
• 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
• 原型模式（Prototype Pattern）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

单例模式（Singleton Pattern）

/**
 * 单例类，保证整个应用程序中只有一个实例存在
 */
public class Singleton {
    // 静态私有成员，存储唯一的实例
    private static Singleton instance;

    // 私有构造函数，防止外部创建实例
    private Singleton() {}

    /**
     * 获取单例实例的公共静态方法
     * 如果实例不存在则创建，存在则直接返回
     * @return 单例实例
     */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

工厂模式（Factory Pattern）

/**
 * 产品接口，定义产品的公共行为
 */
interface Product {
    /**
     * 产品的具体操作
     */
    void doSomething();
}

/**
 * 具体产品 A，实现 Product 接口
 */
class ConcreteProductA implements Product {
    @Override
    /**
     * 具体的操作实现
     */
    public void doSomething() {
        System.out.println("ConcreteProductA is doing something");
    }
}

/**
 * 具体产品 B，实现 Product 接口
 */
class ConcreteProductB implements Product {
    @Override
    /**
     * 具体的操作实现
     */
    public void doSomething() {
        System.out.println("ConcreteProductB is doing something");
    }
}

/**
 * 工厂类，用于创建产品对象
 */
class Factory {
    /**
     * 根据传入的类型创建相应的产品对象
     * @param type 产品类型
     * @return 相应类型的产品对象，如果类型不匹配则返回 null
     */
    public Product createProduct(String type) {
        if ("A".equalsIgnoreCase(type)) {
            return new ConcreteProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

抽象工厂模式（Abstract Factory Pattern）

/**
 * 按钮接口，定义按钮的公共行为
 */
interface Button {
    /**
     * 绘制按钮
     */
    void paint();
}

/**
 * 文本框接口，定义文本框的公共行为
 */
interface TextBox {
    /**
     * 显示文本框
     */
    void display();
}

/**
 * Windows 风格的按钮，实现 Button 接口
 */
class WindowsButton implements Button {
    @Override
    /**
     * Windows 按钮的绘制实现
     */
    public void paint() {
        System.out.println("Windows Button painted");
    }
}

/**
 * Windows 风格的文本框，实现 TextBox 接口
 */
class WindowsTextBox implements TextBox {
    @Override
    /**
     * Windows 文本框的显示实现
     */
    public void display() {
        System.out.println("Windows TextBox displayed");
    }
}

/**
 * Mac 风格的按钮，实现 Button 接口
 */
class MacButton implements Button {
    @Override
    /**
     * Mac 按钮的绘制实现
     */
    public void paint() {
        System.out.println("Mac Button painted");
    }
}

/**
 * Mac 风格的文本框，实现 TextBox 接口
 */
class MacTextBox implements TextBox {
    @Override
    /**
     * Mac 文本框的显示实现
     */
    public void display() {
        System.out.println("Mac TextBox displayed");
    }
}

/**
 * 抽象工厂接口，定义创建按钮和文本框的抽象方法
 */
interface GUIFactory {
    /**
     * 创建按钮
     * @return 按钮对象
     */
    Button createButton();

    /**
     * 创建文本框
     * @return 文本框对象
     */
    TextBox createTextBox();
}

/**
 * Windows 风格的工厂，实现 GUIFactory 接口
 */
class WindowsFactory implements GUIFactory {
    @Override
    /**
     * 创建 Windows 风格的按钮
     * @return Windows 按钮对象
     */
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    /**
     * 创建 Windows 风格的文本框
     * @return Windows 文本框对象
     */
    public TextBox createTextBox() {
        return new WindowsTextBox();
    }
}

/**
 * Mac 风格的工厂，实现 GUIFactory 接口
 */
class MacFactory implements GUIFactory {
    @Override
    /**
     * 创建 Mac 风格的按钮
     * @return Mac 按钮对象
     */
    public Button createButton() {
        return new MacButton();
    }

    @Override
    /**
     * 创建 Mac 风格的文本框
     * @return Mac 文本框对象
     */
    public TextBox createTextBox() {
        return new MacTextBox();
    }
}

建造者模式（Builder Pattern）

/**
 * 计算机类，包含计算机的主要组件信息
 */
class Computer {
    // CPU 型号
    private String cpu;
    // 内存大小
    private String ram;
    // 硬盘容量
    private String hardDisk;

    /**
     * 获取 CPU 型号
     * @return CPU 型号
     */
    public String getCpu() {
        return cpu;
    }

    /**
     * 设置 CPU 型号
     * @param cpu CPU 型号
     */
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    /**
     * 获取内存大小
     * @return 内存大小
     */
    public String getRam() {
        return ram;
    }

    /**
     * 设置内存大小
     * @param ram 内存大小
     */
    public void setRam(String ram) {
        this.ram = ram;
    }

    /**
     * 获取硬盘容量
     * @return 硬盘容量
     */
    public String getHardDisk() {
        return hardDisk;
    }

    /**
     * 设置硬盘容量
     * @param hardDisk 硬盘容量
     */
    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    @Override
    /**
     * 重写 toString 方法，返回计算机的组件信息字符串
     * @return 计算机组件信息字符串
     */
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                '}';
    }
}

/**
 * 计算机建造者类，用于逐步构建计算机对象
 */
class ComputerBuilder {
    private String cpu;
    private String ram;
    private String hardDisk;

    /**
     * 设置 CPU 型号，并返回当前建造者对象，以便链式调用
     * @param cpu CPU 型号
     * @return 当前建造者对象
     */
    public ComputerBuilder setCpu(String cpu) {
        this.cpu = cpu;
        return this;
    }

    /**
     * 设置内存大小，并返回当前建造者对象，以便链式调用
     * @param ram 内存大小
     * @return 当前建造者对象
     */
    public ComputerBuilder setRam(String ram) {
        this.ram = ram;
        return this;
    }

    /**
     * 设置硬盘容量，并返回当前建造者对象，以便链式调用
     * @param hardDisk 硬盘容量
     * @return 当前建造者对象
     */
    public ComputerBuilder setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
        return this;
    }

    /**
     * 构建计算机对象
     * @return 构建完成的计算机对象
     */
    public Computer build() {
        Computer computer = new Computer();
        computer.setCpu(cpu);
        computer.setRam(ram);
        computer.setHardDisk(hardDisk);
        return computer;
    }
}

原型模式（Prototype Pattern）

/**
 * 原型类，实现 Cloneable 接口以支持克隆操作
 */
class Prototype implements Cloneable {

    private String name;
    private List<String> items;

    public Prototype(String name) {
        this.name = name;
        this.items = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<String> getItems() {
        return items;
    }

    public void addItem(String item) {
        items.add(item);
    }

    /**
     * 重写 clone 方法进行深克隆
     * @return 克隆后的对象
     * @throws CloneNotSupportedException 如果不支持克隆则抛出异常
     */
    @Override
    protected Prototype clone() throws CloneNotSupportedException {
        Prototype clone = (Prototype) super.clone();
        // 对引用类型进行深克隆
        clone.items = new ArrayList<>(items);
        return clone;
    }

    @Override
    public String toString() {
        return "Prototype{" +
                "name='" + name + '\'' +
                ", items=" + items +
                '}';
    }
}

public class PrototypePatternExample {

    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建原型对象
        Prototype prototype = new Prototype("Original");
        prototype.addItem("Item 1");
        prototype.addItem("Item 2");

        // 克隆原型对象
        Prototype clone = prototype.clone();
        clone.setName("Clone");
        clone.addItem("Item 3");

        System.out.println("Original: " + prototype);
        System.out.println("Clone: " + clone);
    }
}
//`Prototype`类实现了`Cloneable`接口，并在`clone`方法中对引用类型`items`进行了深克隆，以确保克隆得到的对象与原始对象相互独立。

结构型模式

• 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口。
• 桥接模式（Bridge Pattern）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
• 组合模式（Composite Pattern）：将对象组合成树形结构以表示 “部分 - 整体” 的层次结构。
• 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。
• 外观模式（Facade Pattern）：为子系统中的一组接口提供一个一致的界面。
• 享元模式（Flyweight Pattern）：运用共享技术有效地支持大量细粒度的对象。
• 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。

适配器模式（Adapter Pattern）

interface Target {
    /**
     * 目标接口定义的方法
     */
    void request();
}

class Adaptee {
    /**
     * 被适配者拥有的方法
     */
    public void specificRequest() {
        System.out.println("Specific Request");
    }
}

class Adapter extends Adaptee implements Target {
    @Override
    /**
     * 实现目标接口的方法，通过调用被适配者的方法来适配
     */
    public void request() {
        specificRequest();
    }
}

桥接模式（Bridge Pattern）

/**
 * 抽象化角色
 */
abstract class Abstraction {
    protected Implementor implementor;

    /**
     * 设置实现化角色
     * @param implementor 实现化角色对象
     */
    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }

    /**
     * 抽象方法，由具体的子类实现
     */
    public abstract void operation();
}

/**
 * 扩充抽象化角色
 */
class RefinedAbstraction extends Abstraction {
    @Override
    /**
     * 具体的操作实现，调用实现化角色的方法
     */
    public void operation() {
        implementor.operationImpl();
    }
}

/**
 * 实现化角色
 */
interface Implementor {
    /**
     * 实现化角色的方法
     */
    void operationImpl();
}

/**
 * 具体实现化角色
 */
class ConcreteImplementorA implements Implementor {
    @Override
    /**
     * 具体的实现
     */
    public void operationImpl() {
        System.out.println("Concrete Implementor A");
    }
}

class ConcreteImplementorB implements Implementor {
    @Override
    /**
     * 具体的实现
     */
    public void operationImpl() {
        System.out.println("Concrete Implementor B");
    }
}

组合模式（Composite Pattern）

interface Component {
    /**
     * 操作方法
     */
    void operation();

    /**
     * 添加子组件
     * @param component 子组件
     */
    void add(Component component);

    /**
     * 移除子组件
     * @param component 子组件
     */
    void remove(Component component);

    /**
     * 获取子组件
     * @param index 索引
     * @return 子组件
     */
    Component getChild(int index);
}

class Leaf implements Component {
    private String name;

    /**
     * 构造函数
     * @param name 叶子节点名称
     */
    public Leaf(String name) {
        this.name = name;
    }

    @Override
    /**
     * 叶子节点的操作实现
     */
    public void operation() {
        System.out.println("Leaf: " + name + " is operating");
    }

    @Override
    /**
     * 叶子节点不能添加子组件，空实现
     */
    public void add(Component component) {
        System.out.println("Cannot add to a leaf");
    }

    @Override
    /**
     * 叶子节点不能移除子组件，空实现
     */
    public void remove(Component component) {
        System.out.println("Cannot remove from a leaf");
    }

    @Override
    /**
     * 叶子节点没有子组件，返回 null
     */
    public Component getChild(int index) {
        return null;
    }
}

class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    @Override
    /**
     * 组合节点的操作实现，遍历子组件进行操作
     */
    public void operation() {
        System.out.println("Composite is operating");
        for (Component component : children) {
            component.operation();
        }
    }

    @Override
    /**
     * 添加子组件到组合节点
     */
    public void add(Component component) {
        children.add(component);
    }

    @Override
    /**
     * 从组合节点移除子组件
     */
    public void remove(Component component) {
        children.remove(component);
    }

    @Override
    /**
     * 根据索引获取子组件
     */
    public Component getChild(int index) {
        return children.get(index);
    }
}

装饰器模式（Decorator Pattern）

interface Component {
    /**
     * 核心操作
     */
    void operation();
}

class ConcreteComponent implements Component {
    @Override
    /**
     * 具体组件的操作实现
     */
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}

abstract class Decorator implements Component {
    protected Component component;

    /**
     * 构造函数，传入被装饰的组件
     * @param component 被装饰的组件
     */
    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    /**
     * 委托给被装饰的组件进行操作
     */
    public void operation() {
        component.operation();
    }
}

class ConcreteDecoratorA extends Decorator {
    /**
     * 构造函数
     * @param component 被装饰的组件
     */
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    /**
     * 在被装饰组件操作的基础上添加额外操作
     */
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorA operation");
    }
}

class ConcreteDecoratorB extends Decorator {
    /**
     * 构造函数
     * @param component 被装饰的组件
     */
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    /**
     * 在被装饰组件操作的基础上添加额外操作
     */
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorB operation");
    }
}

外观模式（Facade Pattern）

class SubSystemA {
    /**
     * 子系统 A 的操作
     */
    public void operationA() {
        System.out.println("SubSystemA operation");
    }
}

class SubSystemB {
    /**
     * 子系统 B 的操作
     */
    public void operationB() {
        System.out.println("SubSystemB operation");
    }
}

class SubSystemC {
    /**
     * 子系统 C 的操作
     */
    public void operationC() {
        System.out.println("SubSystemC operation");
    }
}

class Facade {
    private SubSystemA subSystemA;
    private SubSystemB subSystemB;
    private SubSystemC subSystemC;

    /**
     * 构造函数，初始化子系统对象
     */
    public Facade() {
        subSystemA = new SubSystemA();
        subSystemB = new SubSystemB();
        subSystemC = new SubSystemC();
    }

    /**
     * 提供的统一操作接口，组合调用子系统的操作
     */
    public void operation() {
        subSystemA.operationA();
        subSystemB.operationB();
        subSystemC.operationC();
    }
}

享元模式（Flyweight Pattern）

interface Flyweight {
    /**
     * 业务操作
     * @param extrinsicState 外部状态
     */
    void operation(String extrinsicState);
}

class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;

    /**
     * 构造函数，初始化内部状态
     * @param intrinsicState 内部状态
     */
    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    /**
     * 具体的业务操作实现
     */
    public void operation(String extrinsicState) {
        System.out.println("Intrinsic State: " + intrinsicState + ", Extrinsic State: " + extrinsicState);
    }
}

class FlyweightFactory {
    private HashMap<String, Flyweight> flyweights = new HashMap<>();

    /**
     * 获取享元对象
     * @param key 用于标识享元的键
     * @return 对应的享元对象，如果不存在则创建
     */
    public Flyweight getFlyweight(String key) {
        if (!flyweights.containsKey(key)) {
            flyweights.put(key, new ConcreteFlyweight(key));
        }
        return flyweights.get(key);
    }
}

代理模式（Proxy Pattern）

interface Subject {
    /**
     * 主体接口定义的方法
     */
    void request();
}

/**
 * 真实主题类，实现主体接口
 */
class RealSubject implements Subject {
    @Override
    /**
     * 真实主题的请求方法实现
     */
    public void request() {
        System.out.println("RealSubject: Handling request");
    }
}

/**
 * 代理类，同样实现主体接口
 */
class ProxySubject implements Subject {
    private RealSubject realSubject;

    /**
     * 构造函数，初始化时创建真实主题对象（如果需要）
     */
    public ProxySubject() {
        realSubject = new RealSubject();
    }

    @Override
    /**
     * 代理的请求方法，在调用真实主题的请求方法之前或之后可以添加额外的逻辑
     */
    public void request() {
        // 在此处添加前置处理逻辑
        System.out.println("ProxySubject: Pre-processing");
        realSubject.request();
        // 在此处添加后置处理逻辑
        System.out.println("ProxySubject: Post-processing");
    }
}

public class ProxyPatternExample {
    public static void main(String[] args) {
        // 创建代理对象
        Subject proxy = new ProxySubject();
        // 通过代理对象调用方法
        proxy.request();
    }
}

行为型模式

• 责任链模式（Chain of Responsibility Pattern）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
• 命令模式（Command Pattern）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化。
• 解释器模式（Interpreter Pattern）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
• 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。
• 中介者模式（Mediator Pattern）：用一个中介对象来封装一系列的对象交互。
• 备忘录模式（Memento Pattern）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
• 观察者模式（Observer Pattern）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
• 状态模式（State Pattern）：允许一个对象在其内部状态改变时改变它的行为。
• 策略模式（Strategy Pattern）：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。
• 模板方法模式（Template Method Pattern）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
• 访问者模式（Visitor Pattern）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

责任链模式（Chain of Responsibility Pattern）

interface Handler {
    /**
     * 处理请求的方法
     * @param request 请求内容
     */
    void handleRequest(String request);
}

class ConcreteHandler1 implements Handler {
    private Handler nextHandler;

    /**
     * 设置下一个处理器
     * @param nextHandler 下一个处理器对象
     */
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("Request 1")) {
            System.out.println("ConcreteHandler1 handled the request");
        } else if (nextHandler!= null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandler2 implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(String request) {
        if (request.equals("Request 2")) {
            System.out.println("ConcreteHandler2 handled the request");
        } else if (nextHandler!= null) {
            nextHandler.handleRequest(request);
        }
    }
}

命令模式（Command Pattern）

interface Command {
    /**
     * 执行命令的方法
     */
    void execute();
}

class ConcreteCommand implements Command {
    private Receiver receiver;

    /**
     * 构造函数，接收命令的执行者
     * @param receiver 执行者对象
     */
    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

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

class Receiver {
    /**
     * 具体的执行动作
     */
    public void action() {
        System.out.println("Receiver is performing an action");
    }
}

class Invoker {
    private Command command;

    /**
     * 设置要执行的命令
     * @param command 命令对象
     */
    public void setCommand(Command command) {
        this.command = command;
    }

    /**
     * 触发命令执行
     */
    public void invoke() {
        command.execute();
    }
}

解释器模式（Interpreter Pattern）

interface Expression {
    /**
     * 解释表达式的方法
     * @param context 上下文
     * @return 解释结果
     */
    int interpret(Context context);
}

class TerminalExpression implements Expression {
    private int number;

    /**
     * 构造函数
     * @param number 终端表达式的值
     */
    public TerminalExpression(int number) {
        this.number = number;
    }

    @Override
    public int interpret(Context context) {
        return number;
    }
}

class NonTerminalExpression implements Expression {
    private Expression left;
    private Expression right;

    /**
     * 构造函数
     * @param left 左子表达式
     * @param right 右子表达式
     */
    public NonTerminalExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}

class Context {
    // 用于存储解释过程中的相关数据
}

迭代器模式（Iterator Pattern）

interface Iterator {
    /**
     * 是否还有下一个元素
     * @return 如果有下一个元素返回 true，否则返回 false
     */
    boolean hasNext();

    /**
     * 获取下一个元素
     * @return 下一个元素
     */
    Object next();
}

interface Collection {
    /**
     * 获取迭代器对象
     * @return 迭代器对象
     */
    Iterator iterator();
}

class ConcreteCollection implements Collection {
    private Object[] items;
    private int position = 0;

    /**
     * 构造函数
     * @param items 元素数组
     */
    public ConcreteCollection(Object[] items) {
        this.items = items;
    }

    @Override
    public Iterator iterator() {
        return new ConcreteIterator();
    }

    private class ConcreteIterator implements Iterator {
        @Override
        public boolean hasNext() {
            return position < items.length;
        }

        @Override
        public Object next() {
            if (hasNext()) {
                return items[position++];
            }
            return null;
        }
    }
}

中介者模式（Mediator Pattern）

interface Mediator {
    /**
     * 处理同事对象的交互
     * @param colleague 同事对象
     */
    void handleMessage(Colleague colleague);
}

class ConcreteMediator implements Mediator {
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    /**
     * 设置同事对象
     * @param colleagueA 同事 A 对象
     * @param colleagueB 同事 B 对象
     */
    public void setColleagues(ColleagueA colleagueA, ColleagueB colleagueB) {
        this.colleagueA = colleagueA;
        this.colleagueB = colleagueB;
    }

    @Override
    public void handleMessage(Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.action();
        } else if (colleague == colleagueB) {
            colleagueA.action();
        }
    }
}

abstract class Colleague {
    protected Mediator mediator;

    /**
     * 构造函数
     * @param mediator 中介者对象
     */
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    /**
     * 发送消息的抽象方法，由具体子类实现
     */
    public abstract void sendMessage();
}

class ColleagueA extends Colleague {
    public ColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage() {
        System.out.println("ColleagueA sends a message");
        mediator.handleMessage(this);
    }

    public void action() {
        System.out.println("ColleagueA performs an action");
    }
}

class ColleagueB extends Colleague {
    public ColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage() {
        System.out.println("ColleagueB sends a message");
        mediator.handleMessage(this);
    }

    public void action() {
        System.out.println("ColleagueB performs an action");
    }
}

备忘录模式（Memento Pattern）

class Originator {
    private String state;

    /**
     * 设置状态
     * @param state 状态值
     */
    public void setState(String state) {
        this.state = state;
    }

    /**
     * 创建备忘录对象
     * @return 备忘录对象
     */
    public Memento createMemento() {
        return new Memento(state);
    }

    /**
     * 从备忘录对象恢复状态
     * @param memento 备忘录对象
     */
    public void restoreMemento(Memento memento) {
        state = memento.getState();
    }

    @Override
    public String toString() {
        return "Originator{" +
                "state='" + state + '\'' +
                '}';
    }
}

class Memento {
    private String state;

    /**
     * 构造函数，保存状态
     * @param state 要保存的状态
     */
    public Memento(String state) {
        this.state = state;
    }

    /**
     * 获取保存的状态
     * @return 保存的状态
     */
    public String getState() {
        return state;
    }
}

class Caretaker {
    private Memento memento;

    /**
     * 保存备忘录对象
     * @param memento 备忘录对象
     */
    public void saveMemento(Memento memento) {
        this.memento = memento;
    }

    /**
     * 获取保存的备忘录对象
     * @return 备忘录对象
     */
    public Memento getMemento() {
        return memento;
    }
}

观察者模式（Observer Pattern）

interface Observer {
    /**
     * 当主题状态改变时被调用的方法
     * @param state 主题的新状态
     */
    void update(String state);
}

class ConcreteObserver1 implements Observer {
    @Override
    public void update(String state) {
        System.out.println("ConcreteObserver1: " + state);
    }
}

class ConcreteObserver2 implements Observer {
    @Override
    public void update(String state) {
        System.out.println("ConcreteObserver2: " + state);
    }
}

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

    /**
     * 注册观察者
     * @param observer 观察者对象
     */
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    /**
     * 移除观察者
     * @param observer 观察者对象
     */
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 通知所有观察者状态改变
     * @param state 新的状态
     */
    public void notifyObservers(String state) {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

状态模式（State Pattern）

interface State {
    /**
     * 处理请求
     */
    void handle();
}

class ConcreteStateA implements State {
    @Override
    public void handle() {
        System.out.println("In State A");
    }
}

class ConcreteStateB implements State {
    @Override
    public void handle() {
        System.out.println("In State B");
    }
}

class Context {
    private State state;

    /**
     * 设置初始状态
     * @param state 初始状态对象
     */
    public Context(State state) {
        this.state = state;
    }

    /**
     * 改变状态
     * @param state 新的状态对象
     */
    public void setState(State state) {
        this.state = state;
    }

    /**
     * 请求处理，委托给当前状态对象
     */
    public void request() {
        state.handle();
    }
}

策略模式（Strategy Pattern）

interface Strategy {
    /**
     * 执行策略的方法
     */
    void execute();
}

class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy B");
    }
}

class Context {
    private Strategy strategy;

    /**
     * 设置策略
     * @param strategy 策略对象
     */
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 执行策略
     */
    public void performStrategy() {
        strategy.execute();
    }
}

模板方法模式（Template Method Pattern）

abstract class AbstractClass {
    /**
     * 模板方法，定义算法框架
     */
    public void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
    }

    /**
     * 抽象的基本操作 1
     */
    abstract void primitiveOperation1();

    /**
     * 抽象的基本操作 2
     */
    abstract void primitiveOperation2();

    /**
     * 具体操作
     */
    void concreteOperation() {
        System.out.println("Concrete operation");
    }
}

class ConcreteClass extends AbstractClass {
    @Override
    void primitiveOperation1() {
        System.out.println("Primitive Operation 1");
    }

    @Override
    void primitiveOperation2() {
        System.out.println("Primitive Operation 2");
    }
}

访问者模式（Visitor Pattern）

interface Element {
    /**
     * 接受访问者的访问
     * @param visitor 访问者对象
     */
    void accept(Visitor visitor);
}

class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationA() {
        return "ConcreteElementA operation";
    }
}

class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationB() {
        return "ConcreteElementB operation";
    }
}

interface Visitor {
    /**
     * 访问 ConcreteElementA 类型的元素
     * @param elementA ConcreteElementA 类型的元素
     */
    void visit(ConcreteElementA elementA);

    /**
     * 访问 ConcreteElementB 类型的元素
     * @param elementB ConcreteElementB 类型的元素
     */
    void visit(ConcreteElementB elementB);
}

class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ConcreteElementA elementA) {
        System.out.println("Visiting ConcreteElementA: " + elementA.operationA());
    }

    @Override
    public void visit(ConcreteElementB elementB) {
        System.out.println("Visiting ConcreteElementB: " + elementB.operationB());
    }
}

Java 中常见设计模式的应用场景

单例模式（Singleton Pattern）：

• 当需要确保一个类只有一个实例存在，并且全局都可以访问这个唯一实例时，比如日志记录器、数据库连接池、线程池等。

工厂模式（Factory Pattern）：

• 当创建对象的逻辑比较复杂，或者需要根据不同的条件创建不同的对象时，可以将对象的创建封装在工厂类中，提高代码的可维护性和可扩展性。例如创建不同类型的产品、不同风格的界面组件。

抽象工厂模式（Abstract Factory Pattern）：

• 当需要创建一系列相关或相互依赖的对象，而这些对象的创建又需要遵循一定的规则和约束时，比如不同操作系统下的图形界面组件的创建。

建造者模式（Builder Pattern）：

• 当对象的创建需要很多步骤，并且这些步骤的顺序或者参数的组合方式可能不同时，适合使用建造者模式。例如创建复杂的对象，如配置文件、复杂的报表等。

原型模式（Prototype Pattern）：

• 当需要创建对象的副本，或者从一个对象克隆出多个相似对象时，特别是对象创建成本较高，或者需要在运行时动态创建对象的情况。

适配器模式（Adapter Pattern）：

• 当需要将一个类的接口转换成客户希望的另一个接口时，比如将一个老的接口适配成新的接口，或者将不同类库的接口进行适配。

桥接模式（Bridge Pattern）：

• 当一个类存在多个维度的变化，并且这些变化可以独立进行时，将抽象和实现分离，使它们可以独立地变化。

组合模式（Composite Pattern）：

• 当需要处理具有层次结构的数据，并且希望以统一的方式对待单个对象和对象组合时，比如文件系统、组织结构等。

装饰器模式（Decorator Pattern）：

• 当需要动态地为对象添加额外的功能，而不改变对象的原有结构和功能时，可以使用装饰器模式。

外观模式（Facade Pattern）：

• 为子系统中的一组接口提供一个统一的高层接口，使得子系统更容易使用。例如，为复杂的库或框架提供一个简单的接口。

享元模式（Flyweight Pattern）：

• 当系统中存在大量相似的对象，并且这些对象耗费大量的内存时，可以使用享元模式来共享对象，减少内存消耗。

责任链模式（Chain of Responsibility Pattern）：

• 当有多个对象可以处理一个请求，并且具体由哪个对象处理在运行时动态决定时，比如审批流程、事件处理链等。

命令模式（Command Pattern）：

• 将请求封装成对象，以便支持请求的排队、记录日志、撤销等操作。常用于菜单操作、事务处理等场景。

解释器模式（Interpreter Pattern）：

• 当需要定义一种语言的文法，并解释语言中的句子时，例如自定义的表达式求值、脚本语言的解释等。

迭代器模式（Iterator Pattern）：

• 当需要遍历一个聚合对象中的元素，而又不暴露其内部表示时，比如遍历各种集合类。

中介者模式（Mediator Pattern）：

• 当多个对象之间存在复杂的交互关系，并且这些关系混乱难以维护时，通过中介者来协调这些对象之间的通信。

备忘录模式（Memento Pattern）：

• 在不破坏对象封装性的前提下，捕获和保存对象的内部状态，以便在需要时能够恢复到之前的状态。

观察者模式（Observer Pattern）：

• 当一个对象的状态改变需要通知其他多个对象，并且这些对象的具体数量和类型不确定时，比如事件监听、消息推送等。

状态模式（State Pattern）：

• 当一个对象的行为取决于它的内部状态，并且状态的数量较多、状态转换复杂时，将状态封装为独立的类。

策略模式（Strategy Pattern）：

• 当在不同的算法或者策略之间进行切换，并且这些算法或者策略可以独立变化时。

模板方法模式（Template Method Pattern）：

• 当一个算法的框架已经确定，但是某些步骤的具体实现由子类来完成时，比如框架中的一些固定流程和可扩展的步骤。

访问者模式（Visitor Pattern）：

• 当需要对一个复杂的对象结构中的元素进行不同的操作，而不改变这些元素的类结构时。

需要注意的是，设计模式的应用不是绝对的，具体的使用需要根据项目的实际需求和架构来决定。