在Java开发中，设计模式提供了一种可重用的解决方案，帮助开发者以更高效和可维护的方式构建系统。

下面，我们将详细介绍三种常用的设计模式：单例模式、工厂模式和观察者模式，并通过具体示例来说明它们的使用场景和实现方式。

1. 单例模式（Singleton Pattern）

理论知识

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于需要控制资源的场景，例如数据库连接池、日志记录器等。

应用场景

• 数据库连接：在应用程序中，通常需要对数据库进行多次连接，使用单例模式可以确保只有一个数据库连接实例，避免了重复连接带来的性能问题。

• 日志记录：应用程序中的日志记录器通常只需要一个实例来写入日志文件。

实现方式

单例模式有多种实现方式，最常见的是懒汉式和饿汉式。

懒汉式单例实现（线程不安全）：

public class LazySingleton {
    private static LazySingleton instance;

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

    // 提供全局访问点
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton(); // 延迟实例化
        }
        return instance;
    }
}

懒汉式单例实现（线程安全）：

public class ThreadSafeLazySingleton {
    private static ThreadSafeLazySingleton instance;

    // 私有构造函数
    private ThreadSafeLazySingleton() {}

    // 提供全局访问点
    public static synchronized ThreadSafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazySingleton(); // 延迟实例化
        }
        return instance;
    }
}

饿汉式单例实现：

public class EagerSingleton {
    // 在类加载时立即创建实例
    private static final EagerSingleton instance = new EagerSingleton();

    // 私有构造函数
    private EagerSingleton() {}

    // 提供全局访问点
    public static EagerSingleton getInstance() {
        return instance;
    }
}

2. 工厂模式（Factory Pattern）

理论知识

工厂模式是一种创建对象的设计模式，它定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂模式可以分为简单工厂、工厂方法和抽象工厂。

应用场景

• 图形界面组件：在不同操作系统中，按钮、文本框等组件的实现可能不同，工厂模式可以根据操作系统类型创建相应的组件。

• 数据库连接：根据不同的数据库类型（如MySQL、Oracle），工厂模式可以创建不同的连接对象。

实现方式

简单工厂模式：

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use(); // 输出: 使用产品A

        Product productB = SimpleFactory.createProduct("B");
        productB.use(); // 输出: 使用产品B
    }
}

工厂方法模式：

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // 输出: 使用产品A

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // 输出: 使用产品B
    }
}

3. 观察者模式（Observer Pattern）

理论知识

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，所有依赖于它的观察者都会收到通知并自动更新。这种模式常用于事件处理系统。

应用场景

• 事件监听：GUI框架中的按钮点击事件、文本框内容变化等。

• 消息推送：社交媒体应用中的新消息通知。

实现方式

import java.util.ArrayList;
import java.util.List;

// 主题接口
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

// 观察者接口
interface Observer {
    void update(String message);
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

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

    public void detach(Observer observer) {
        observers.remove(observer);
    }

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

    public void setState(String state) {
        this.state = state;
        notifyObservers(); // 状态变化时通知所有观察者
    }
}

// 具体观察者
class ConcreteObserverA implements Observer {
    public void update(String message) {
        System.out.println("观察者A收到消息: " + message);
    }
}

class ConcreteObserverB implements Observer {
    public void update(String message) {
        System.out.println("观察者B收到消息: " + message);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserverA observerA = new ConcreteObserverA();
        ConcreteObserverB observerB = new ConcreteObserverB();

        subject.attach(observerA);
        subject.attach(observerB);

        subject.setState("状态更新1"); // 观察者A和B都会收到消息
        subject.setState("状态更新2"); // 观察者A和B都会收到消息
    }
}