java常用的设计模式有哪些

// 单例模式 (Singleton Pattern)
public class Singleton {
    // 私有静态变量保存唯一实例
    private static Singleton uniqueInstance;

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

    // 公有静态方法提供全局访问点
    public static synchronized Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

// 工厂方法模式 (Factory Method Pattern)
interface Product {
    void use();
}

class ConcreteProduct implements Product {
    public void use() {
        System.out.println("ConcreteProduct is used.");
    }
}

abstract class Creator {
    public final Product factoryMethod() {
        Product product = this.createProduct();
        this.postProcess(product);
        return product;
    }

    protected abstract Product createProduct();

    protected void postProcess(Product product) {
        // Additional processing after product creation
    }
}

class ConcreteCreator extends Creator {
    protected Product createProduct() {
        return new ConcreteProduct();
    }
}

// 观察者模式 (Observer Pattern)
interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

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

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

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

解释说明：

1. 单例模式 (Singleton Pattern)：

   • 通过私有静态变量 uniqueInstance 来保存唯一的实例。
   • 使用私有构造函数防止外部实例化。
   • 提供公有的静态方法 getInstance() 来获取唯一的实例，并确保线程安全。

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

   • 定义了一个 Product 接口和一个具体的实现类 ConcreteProduct。
   • 抽象类 Creator 中定义了 factoryMethod() 方法，该方法负责创建产品对象。
   • 具体的子类 ConcreteCreator 实现了 createProduct() 方法来创建具体的产品对象。

3. 观察者模式 (Observer Pattern)：

   • 定义了 Observer 接口和具体的观察者类 ConcreteObserver。
   • 定义了 Subject 接口和具体的主题类 ConcreteSubject。
   • 观察者可以注册到主题中，当主题状态改变时，通知所有已注册的观察者。