Java设计模式：工厂方法、单例、观察者等实例解析

原创秒速五厘米 2024-12-04 06:00 44阅读 0赞

在Java编程中，设计模式是解决常见问题的一种规范化思路。这里我们分别解析一下“工厂方法”、“单例”和“观察者”这三个设计模式的实例。

1. 工厂方法（Factory Method Pattern）

工厂方法是一种创建型模式，它使子类不需要依赖于它们的具体父类类型就能创建它们的对象。实例：

```java
// 定义抽象工厂接口
abstract class AbstractFactory {
    // 创建具体产品的工厂方法
    abstract Product createProduct();
}

// 具体产品（可以是汽车、手机等）
class Product {
    // 产品属性或功能
    String name;
    
    // 构造函数
    Product(String name) {
        this.name = name;
    }
}

// 工厂类，实现抽象工厂接口
class ConcreteFactory extends AbstractFactory {
    @Override
    Product createProduct() {
        return new Car("Toyota Corolla");
    }
}

// 产品使用示例（汽车）
class Client {
    public static void main(String[] args) {
        // 创建具体工厂对象
        ConcreteFactory factory = new ConcreteFactory();
        
        // 使用工厂创建并使用产品
        Car corolla = factory.createProduct();
        System.out.println(corolla.getName());  // 输出：Toyota Corolla
    }
}
```

2. 单例（Singleton Pattern）

单例模式保证一个类只有一个实例，并提供全局访问点。实例：

```java
// 简单的单例类
public class Singleton {
    // 隐藏构造函数，防止直接创建对象
    private Singleton() {}

// 获取唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

// 用于测试的属性
    private String message;

// 设置或获取消息
    public void setMessage(String message) {
        this.message = message;
    }

public String getMessage() {
        return message;
    }
}

// 测试单例类（保证实例唯一）
public class SingletonTest {
    public static void main(String[] args) {
        // 获取单例实例，如果还没有实例，则创建
        Singleton singletonInstance1 = Singleton.getInstance();
        Singleton singletonInstance2 = Singleton.getInstance();

// 检查两个实例是否相同（引用）
        System.out.println(singletonInstance1 == singletonInstance2));  // 输出：false

// 设置消息，并验证
        singletonInstance1.setMessage("Hello, Singleton!");
        System.out.println(singletonInstance1.getMessage()));  // 输出：Hello, Singleton!

// 单例再次获取实例，应为同一实例（引用）
        System.out.println(Singleton.getInstance() == singletonInstance1));  // 输出：true

// 对象移除引用后应该变为null
        singletonInstance1 = null;
        if (singletonInstance1 != null) {
            System.out.println("错误：对象已设置为null，但不应该等于null。");  // 输出：错误：对象已设置为null，但不应该等于null。
        }
    }
}
```

3. 观察者（Observer Pattern）

观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知并自动更新。

实例：

```java
// 定义抽象主题类（被观察者）
abstract class Subject {
    // 存储所有的观察者
    private List<Observer> observers;

// 注册观察者
    public void register(Observer observer) {
        if (observers == null) {
            observers = new ArrayList<>();
        }
        observers.add(observer);
    }

// 移除观察者（注册的观察者）
    public void removeObserver(Observer observer) {
        if (observers != null) {
            observers.remove(observer);
        }
    }

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

// 通知所有观察者
    protected void notifyObservers(String message) {
        if (observers != null) {
            for (Observer observer : observers) {
                observer.update(message);
            }
        }
    }
}

// 定义具体主题类（被观察者）
class StockPriceSubject implements Subject {
    private String stockSymbol = "AAPL";
    private double currentPrice;

// 设置股票代码
    public void setStockSymbol(String symbol) {
        this.stockSymbol = symbol;
    }

// 获取当前股票价格
    public double getCurrentPrice() {
        return this.currentPrice;
    }

// 更新股票价格
    protected void updatePrice(double newPrice) {
        this.currentPrice = newPrice;
        notifyObservers(stockSymbol + "的新价格：" + newPrice));
    }
}

// 定义具体观察者类（订阅者）
class StockPriceObserver implements Observer {
    private String stockSymbol;

// 订阅股票代码
    public void subscribe(String symbol) {
        this.stockSymbol = symbol;
    }

// 取消订阅（停止接收通知）
    public void unsubscribe() {
        this.stockSymbol = null;  // 指针置空表示取消订阅
    }

// 接收并处理股票价格通知
    @Override
    public void update(String message) {
        if (stockSymbol != null && message.contains(stockSymbol))) {
            System.out.println("收到来自 " + stockSymbol + " 的股票价格更新：" + message);
            // 在这里你可以模拟发送邮件、推送通知等操作
        }
    }
}

// 测试代码
public class StockPriceTest {
    public static void main(String[] args) {
        // 创建主题类（被观察者）
        StockPriceSubject stockSubject = new StockPriceSubject();
        stockSubject.setStockSymbol("AAPL");

// 创建观察者类（订阅者）
        StockPriceObserver observer1 = new StockPriceObserver();
        observer1.subscribe(stockSubject.getStockSymbol()));

// 创建另一个观察者类（订阅者）
        StockPriceObserver observer2 = new StockPriceObserver();
        observer2.subscribe(stockSubject.getStockSymbol()));

// 观察者更新股票价格通知
        stockSubject.updatePrice(150.0));  // 股票价格更新为150

// 验证观察者是否收到通知
        System.out.println("观察者 " + observer1.getStockSymbol() + " 的状态：");
        observer1.updateMessage("股票价格已更新至150美元。");  // 发送更新消息
        if (observer1.getMessage().contains(observer1.getStockSymbol())) && observer1.getMessage().contains("150.0"))) {
            System.out.println(observer1.getMessage()));
            System.out.println("观察者 " + observer2.getStockSymbol() + " 的状态：");
            observer2.updateMessage("同样，股票价格已更新至150美元。");  // 同样发送更新消息
            if (observer2.getMessage().contains(observer2.getStockSymbol())) && observer2.getMessage().contains("150.0"))) {
                System.out.println(observer2.getMessage()));
                System.out.println("测试成功！");
            } else {
                System.out.println("测试失败：观察者 " + observer2.getStockSymbol() + " 没有收到更新通知。");
            }
        }
    }
}
```

以上代码定义了观察者模式的基本组件，包括主题（被观察者）、观察者（订阅者）以及通知（更新消息）。然后在`StockPriceTest`类中进行了测试，确保观察者能够接收到主题的更新通知。