svg图片做网站背景十大免费域名
设计模式是一套被反复使用的、代码设计经验的总结。它们被用来解决软件开发中的某些常见问题，提高代码的可维护性、可扩展性和重用性。设计模式主要分为三大类：创建型模式、结构型模式和行为型模式。以下是一些常见的设计模式及其简要说明：
创建型模式
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
通过这些设计模式，可以提高代码的结构性和可维护性，使软件开发更加高效和灵活。每种模式都有其适用场景，理解并正确应用这些模式是提升编程能力的重要途径。