第八章：设计模式

8.2 常用设计模式（单例、工厂、观察者、策略等）

设计模式是解决软件设计中常见问题的可复用方案。以下是Java中常用的设计模式及其实现方式：

1. 单例模式（Singleton）

目的：确保一个类只有一个实例，并提供全局访问点。
实现方式：

public class Singleton {
    private static Singleton instance;

    // 私有构造方法防止外部实例化
    private Singleton() {}

    // 懒汉式（线程不安全）
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // 懒汉式（线程安全，加锁）
    public static synchronized Singleton getInstanceThreadSafe() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // 饿汉式（类加载时初始化，线程安全）
    private static final Singleton eagerInstance = new Singleton();
    public static Singleton getEagerInstance() {
        return eagerInstance;
    }
}

应用场景：数据库连接池、日志管理器、配置类等。

2. 工厂模式（Factory）

目的：将对象的创建逻辑封装起来，客户端无需关心具体实现。
类型：

  1. 简单工厂模式：
public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A": return new ProductA();
            case "B": return new ProductB();
            default: throw new IllegalArgumentException("Unknown product type");
        }
    }
}
  1. 工厂方法模式：
public interface Factory {
    Product createProduct();
}

public class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
  1. 抽象工厂模式：
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() { return new ProductA1(); }
    @Override
    public ProductB createProductB() { return new ProductB1(); }
}

应用场景：JDBC连接工厂、UI组件库等。

3. 观察者模式（Observer）

目的：定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象会被自动通知。
实现方式：

// 主题接口
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 具体主题
public class WeatherStation implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private float temperature;

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

    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(temperature);
        }
    }
}

// 观察者接口
public interface Observer {
    void update(float temperature);
}

// 具体观察者
public class Display implements Observer {
    @Override
    public void update(float temperature) {
        System.out.println("Temperature updated: " + temperature);
    }
}

应用场景：事件驱动系统、消息订阅（如Java的PropertyChangeListener）。

4. 策略模式（Strategy）

目的：定义一系列算法，封装每个算法，并使它们可以互相替换。
实现方式：

// 策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paid via Credit Card: $" + amount);
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paid via PayPal: $" + amount);
    }
}

// 上下文类
public class ShoppingCart {
    private PaymentStrategy strategy;

    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void checkout(int amount) {
        strategy.pay(amount);
    }
}

应用场景：支付方式选择、排序算法切换等。

其他常用模式

  • 装饰器模式（Decorator）：动态扩展对象功能（如Java I/O流）。
  • 代理模式（Proxy）：控制对象访问（如远程代理、虚拟代理）。
  • 模板方法模式（Template Method）：定义算法骨架，子类实现具体步骤（如AbstractList）。

设计模式的选择原则

  1. 优先组合而非继承：减少耦合。
  2. 开闭原则：对扩展开放，对修改关闭。
  3. 单一职责原则：一个类只负责一个功能。
Last Updated::