# 常见设计模式总结

## 创建型模式

创建型模式主要关注对象的创建过程，常见的模式包括：

### 1. 单例模式 (Singleton)

确保一个类只有一个实例，并提供全局访问点。

**应用场景**:

* 配置管理类
* 线程池管理

**示例代码**:

```java
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
```

### 2. 工厂方法模式 (Factory Method)

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

**应用场景**:

* 当一个类不知道它所必须创建的对象的类时

**示例代码**:

```java
abstract class Product {
    public abstract void use();
}

class ConcreteProductA extends Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

abstract class Creator {
    public abstract Product factoryMethod();
}

class ConcreteCreatorA extends Creator {
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}
```

### 3. 抽象工厂模式 (Abstract Factory)

提供一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。

**应用场景**:

* 需要创建一系列相关的产品对象

**示例代码**:

```java
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

class WinFactory implements GUIFactory {
    public Button createButton() {
        return new WinButton();
    }
    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}
```

### 4. 建造者模式 (Builder)

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

**应用场景**:

* 创建复杂对象的过程

**示例代码**:

```java
class Product {
    private String partA;
    private String partB;

    public void setPartA(String partA) { this.partA = partA; }
    public void setPartB(String partB) { this.partB = partB; }
}

class Builder {
    private Product product = new Product();

    public void buildPartA() { product.setPartA("Part A"); }
    public void buildPartB() { product.setPartB("Part B"); }
    public Product getResult() { return product; }
}
```

### 5. 原型模式 (Prototype)

通过复制现有的实例来创建新的实例。

**应用场景**:

* 当创建对象的成本较高时

**示例代码**:

```java
abstract class Prototype {
    public abstract Prototype clone();
}

class ConcretePrototype extends Prototype {
    public Prototype clone() {
        return new ConcretePrototype();
    }
}
```

## 结构型模式

结构型模式关注类或对象的组合，常见的模式包括：

### 1. 适配器模式 (Adapter)

将一个类的接口转换成客户希望的另一个接口。

**应用场景**:

* 需要使用一个已有的类，但其接口不符合需求

**示例代码**:

```java
class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request");
    }
}

class Adapter extends Adaptee {
    public void request() {
        specificRequest();
    }
}
```

### 2. 装饰器模式 (Decorator)

动态地给一个对象添加一些额外的职责。

**应用场景**:

* 需要扩展一个类的功能

**示例代码**:

```java
interface Coffee {
    String getDescription();
    double cost();
}

class SimpleCoffee implements Coffee {
    public String getDescription() { return "Simple coffee"; }
    public double cost() { return 5; }
}

class MilkDecorator implements Coffee {
    private Coffee coffee;

    public MilkDecorator(Coffee coffee) { this.coffee = coffee; }
    public String getDescription() { return coffee.getDescription() + ", milk"; }
    public double cost() { return coffee.cost() + 1; }
}
```

### 3. 代理模式 (Proxy)

为其他对象提供一种代理以控制对这个对象的访问。

**应用场景**:

* 需要控制对某个对象的访问

**示例代码**:

```java
interface Subject {
    void request();
}

class RealSubject implements Subject {
    public void request() {
        System.out.println("Real subject request");
    }
}

class Proxy implements Subject {
    private RealSubject realSubject;

    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
    }
}
```

### 4. 外观模式 (Facade)

为复杂子系统提供一个统一的接口。

**应用场景**:

* 简化与复杂系统的交互

**示例代码**:

```java
class SubsystemA {
    public void operationA() { System.out.println("Operation A"); }
}

class SubsystemB {
    public void operationB() { System.out.println("Operation B"); }
}

class Facade {
    private SubsystemA a = new SubsystemA();
    private SubsystemB b = new SubsystemB();

    public void operation() {
        a.operationA();
        b.operationB();
    }
}
```

### 5. 桥接模式 (Bridge)

将抽象部分与实现部分分离，使它们可以独立变化。

**应用场景**:

* 当需要在多个维度上变化时

**示例代码**:

```java
interface Implementor {
    void operation();
}

class ConcreteImplementorA implements Implementor {
    public void operation() { System.out.println("Implementation A"); }
}

abstract class Abstraction {
    protected Implementor implementor;

    public Abstraction(Implementor implementor) { this.implementor = implementor; }
    public abstract void operation();
}

class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor implementor) { super(implementor); }
    public void operation() { implementor.operation(); }
}
```

### 6. 组合模式 (Composite)

将对象组合成树形结构以表示部分-整体的层次。

**应用场景**:

* 需要表示部分与整体的层次结构

**示例代码**:

```java
interface Component {
    void operation();
}

class Leaf implements Component {
    public void operation() { System.out.println("Leaf operation"); }
}

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

    public void add(Component component) { children.add(component); }
    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }
}
```

### 7. 享元模式 (Flyweight)

运用共享技术有效地支持大量细粒度的对象。

**应用场景**:

* 当需要大量相似对象时

**示例代码**:

```java
class Flyweight {
    private String intrinsicState;

    public Flyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    public void operation(String extrinsicState) {
        System.out.println("Intrinsic: " + intrinsicState + ", Extrinsic: " + extrinsicState);
    }
}

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

    public Flyweight getFlyweight(String key) {
        if (!flyweights.containsKey(key)) {
            flyweights.put(key, new Flyweight(key));
        }
        return flyweights.get(key);
    }
}
```

## 行为型模式

行为型模式关注对象之间的交互，常见的模式包括：

### 1. 观察者模式 (Observer)

定义对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都得到通知。

**应用场景**:

* 事件处理系统

**示例代码**:

```java
interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer {
    public void update(String message) {
        System.out.println("Received message: " + message);
    }
}

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

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

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}
```

### 2. 策略模式 (Strategy)

定义一系列算法, 将每一个算法封装起来, 并使它们可以互换。

**应用场景**:

* 需要在运行时选择算法

**示例代码**:

```java
interface Strategy {
    void execute();
}

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

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) { this.strategy = strategy; }
    public void executeStrategy() { strategy.execute(); }
}
```

### 3. 命令模式 (Command)

将请求封装为对象，从而使您可以使用不同的请求、队列或日志请求，以及支持可撤销操作。

**应用场景**:

* 需要将操作参数化

**示例代码**:

```java
interface Command {
    void execute();
}

class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) { this.receiver = receiver; }
    public void execute() { receiver.action(); }
}

class Receiver {
    public void action() { System.out.println("Receiver action"); }
}

class Invoker {
    private Command command;

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

### 4. 状态模式 (State)

允许对象在内部状态改变时改变它的行为。

**应用场景**:

* 需要根据状态改变行为

**示例代码**:

```java
interface State {
    void handle();
}

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

class Context {
    private State state;

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

### 5. 责任链模式 (Chain of Responsibility)

使多个对象都有机会处理请求，从而避免请求发送者与接收者之间的耦合。

**应用场景**:

* 处理请求的不同级别

**示例代码**:

```java
abstract class Handler {
    protected Handler next;

    public void setNext(Handler next) { this.next = next; }
    public abstract void handleRequest(int request);
}

class ConcreteHandlerA extends Handler {
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("Handler A handling request " + request);
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}

class ConcreteHandlerB extends Handler {
    public void handleRequest(int request) {
        if (request >= 10) {
            System.out.println("Handler B handling request " + request);
        }
    }
}
```

### 6. 备忘录模式 (Memento)

在不违反封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

**应用场景**:

* 需要保存和恢复对象的状态

**示例代码**:

```java
class Memento {
    private String state;

    public Memento(String state) { this.state = state; }
    public String getState() { return state; }
}

class Originator {
    private String state;

    public void setState(String state) { this.state = state; }
    public Memento saveStateToMemento() { return new Memento(state); }
    public void getStateFromMemento(Memento memento) { state = memento.getState(); }
}
```

### 7. 访问者模式 (Visitor)

表示一个作用于某对象结构中的各元素的操作。

**应用场景**:

* 需要对对象结构中的元素进行操作

**示例代码**:

```java
interface Visitor {
    void visit(Element element);
}

class ConcreteVisitor implements Visitor {
    public void visit(Element element) {
        System.out.println("Visiting " + element.getName());
    }
}

abstract class Element {
    public abstract String getName();
    public abstract void accept(Visitor visitor);
}

class ConcreteElementA extends Element {
    public String getName() { return "Element A"; }
    public void accept(Visitor visitor) { visitor.visit(this); }
}
```

### 8. 中介者模式 (Mediator)

定义一个中介对象来封装一系列的对象交互。

**应用场景**:

* 需要减少多个对象之间的复杂交互

**示例代码**:

```java
class Mediator {
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) { this.colleagueA = colleagueA; }
    public void setColleagueB(ColleagueB colleagueB) { this.colleagueB = colleagueB; }

    public void colleagueChanged() {
        // 处理交互逻辑
    }
}

class ColleagueA {
    private Mediator mediator;

    public ColleagueA(Mediator mediator) { this.mediator = mediator; }
}

class ColleagueB {
    private Mediator mediator;

    public ColleagueB(Mediator mediator) { this.mediator = mediator; }
}
```

### 9. 解释器模式 (Interpreter)

给定一个语言, 定义它的文法表示, 并定义一个解释器来处理该语言。

**应用场景**:

* 需要解释特定语言的场景

**示例代码**:

```java
interface Expression {
    boolean interpret(String context);
}

class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) { this.data = data; }
    public boolean interpret(String context) { return context.contains(data); }
}

class OrExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://gists.lanlance.cn/cssys/depa.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.