设计模式在Java中的应用：观察者、工厂方法等实例

原创布满荆棘的人生 2024-12-10 22:51 18阅读 0赞

设计模式是面向对象编程中解决常见问题的最佳实践经验。以下是在Java中使用观察者（Observer Pattern）和工厂方法（Factory Method Pattern）的两个实例：

1. 观察者模式（Observer Pattern）

```java
// 1. 创建抽象主题类
public abstract class Subject {
    // 2. 提供添加和删除观察者的接口
    public abstract void attach(Observer observer);
    public abstract void detach(Observer observer);
}

// 3. 定义具体主题类
class ConcreteSubject : Subject {
    private List<Observer> observers = new ArrayList<>();

// 实现抽象方法，当状态改变时通知所有观察者
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

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

// 当主题状态改变时，触发通知行为
    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
}

// 4. 定义抽象观察者类
public abstract class Observer {
    public abstract void update(Subject subject);
}

// 5. 创建具体观察者类
class ConcreteObserver : Observer {
    @Override
    public void update(Subject subject) {
        if (subject instanceof ConcreteSubject) {
            System.out.println("Concrete Subject state changed: " + ((ConcreteSubject) subject).getStatus());
        }
    }
}
```

在这个例子中，`ConcreteSubject`是主题（Subject），`ConcreteObserver`是观察者（Observer）。当`ConcreteSubject`的状态改变时，会通知所有订阅它的观察者。

2. 工厂方法模式（Factory Method Pattern）

```java
// 6. 创建抽象产品类
public abstract class Product {
    // 7. 提供创建产品的工厂方法
    public static Product createProduct(String type) {
        switch (type) {
            case "ProductA":
                return new ConcreteProductA();
            case "ProductB":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }

// 保护产品创建方法，防止外部直接调用
    protected Product() {}
}

// 8. 定义具体的抽象产品类
class ConcreteProductA : Product {
    @Override
    public String getProductType() {
        return "ProductA";
    }
}

class ConcreteProductB : Product {
    @Override
    public String getProductType() {
        return "ProductB";
    }
}
```

在这个例子中，`Product`是抽象产品（Product），`ConcreteProductA`和`ConcreteProductB`是具体的抽象产品。工厂方法（Factory Method）提供了一种创建对象的机制，而不是直接访问对象实例。