Java设计模式实践：工厂方法、观察者模式在Java中的具体运用？

原创 ╰+哭是因爲堅強的太久メ 2024-11-06 23:06 20阅读 0赞

Java设计模式是一套被广泛认可的最佳实践，用于解决特定类型的软件设计问题。工厂方法模式和观察者模式是两种常见的设计模式，它们在Java中的运用如下：

###工厂方法模式（Factory Method Pattern）

工厂方法模式是一种创建型模式，它定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

**具体运用：**

1. **定义产品接口**：首先定义一个产品接口，所有的产品类都将实现这个接口。
2. **创建具体产品类**：实现产品接口的具体产品类。
3. **定义工厂接口**：定义一个工厂接口，该接口包含一个工厂方法，用于返回产品对象。
4. **创建具体工厂类**：实现工厂接口的具体工厂类，每个工厂类返回一个具体产品类的实例。

**示例代码：**

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

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

class ConcreteProductB implements Product {
 public void use() {
 System.out.println("Using ConcreteProductB");
 }
}

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

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

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

//客户端代码public class FactoryMethodPatternDemo {
 public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.factoryMethod();
 productA.use();

Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.factoryMethod();
 productB.use();
 }
}
```###观察者模式（Observer Pattern）

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

**具体运用：**

1. **定义观察者接口**：观察者需要实现一个更新接口。
2. **创建具体观察者类**：实现观察者接口的具体观察者类。
3. **定义主题接口**：主题需要维护一个观察者列表，并提供注册和注销观察者的方法。
4. **创建具体主题类**：实现主题接口的具体主题类。
5. **客户端代码**：创建主题和观察者对象，注册观察者，并在主题状态改变时通知观察者。

**示例代码：**

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

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

class ConcreteObserverB implements Observer {
 public void update(String message) {
 System.out.println("ConcreteObserverB: " + message);
 }
}

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

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

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

public void removeObserver(Observer o) {
 observers.remove(o);
 }

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

public void setState(String state) {
 this.state = state;
 notifyObservers();
 }
}

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

subject.registerObserver(observerA);
 subject.registerObserver(observerB);

subject.setState("State1");
 subject.setState("State2");
 }
}
```这些模式在实际开发中非常实用，可以帮助你写出更加灵活、可扩展和可维护的代码。