常见的设计模式

设计模式是一套被反复使用的、代码设计经验的总结。它们被用来解决软件开发中的某些常见问题，提高代码的可维护性、可扩展性和重用性。设计模式主要分为三大类：创建型模式、结构型模式和行为型模式。以下是一些常见的设计模式及其简要说明：

创建型模式

1. 单例模式（Singleton Pattern）
**目的**：确保一个类只有一个实例，并提供一个全局访问点。
**实现**：通过私有化构造函数和静态方法创建实例。
```java
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

2. 工厂方法模式（Factory Method Pattern）
**目的**：定义一个用于创建对象的接口，让子类决定实例化哪个类。
**实现**：通过在子类中重写工厂方法来创建具体对象。
```java
abstract class Creator {
    public abstract Product factoryMethod();
}

class ConcreteCreator extends Creator {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}
```

3. 抽象工厂模式（Abstract Factory Pattern）
**目的**：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
**实现**：通过抽象工厂定义一组创建方法，由具体工厂类实现这些方法。
```java
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

class WinFactory implements GUIFactory {
    public Button createButton() {
        return new WinButton();
    }

    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}
```

结构型模式

 4. 适配器模式（Adapter Pattern）
**目的**：将一个类的接口转换为客户希望的另一个接口，使得原本不兼容的类可以一起工作。
**实现**：通过适配器类实现目标接口，并在内部调用实际接口的方法。
```java
interface Target {
    void request();
}

class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        adaptee.specificRequest();
    }
}
```

5. 装饰器模式（Decorator Pattern）
**目的**：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。
**实现**：通过创建一个装饰类包装原始类，并在装饰类中调用原始类的方法。
```java
interface Component {
    void operation();
}

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

class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        component.operation();
    }
}
```

行为型模式

6. 策略模式（Strategy Pattern）
**目的**：定义一系列算法，将每一个算法封装起来，并让它们可以互换。
**实现**：通过定义一个策略接口，并由具体策略类实现该接口。
```java
interface Strategy {
    void execute();
}

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

class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}
```

7. 观察者模式（Observer Pattern）
**目的**：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖的对象都会得到通知并被自动更新。
**实现**：通过在目标对象中维护观察者列表，并在状态变化时通知所有观察者。
```java
interface Observer {
    void update();
}

class ConcreteObserver implements Observer {
    public void update() {
        System.out.println("Observer updated");
    }
}

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

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

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

参考资源

- **《设计模式：可复用面向对象软件的基础》** by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
- **Refactoring Guru**：[Design Patterns](https://refactoring.guru/design-patterns)
- **Head First Design Patterns** by Eric Freeman, Elisabeth Robson

通过这些设计模式，可以提高代码的结构性和可维护性，使软件开发更加高效和灵活。每种模式都有其适用场景，理解并正确应用这些模式是提升编程能力的重要途径。