Java设计模式泛型化之观察者模式

在观察者模式中有两种不同类型的对象：

被观察者（subject）
观察者（observer）

通常这个设计模式的结构是这样：

被观察者决定了谁可以获得它的更新或者谁不可以，并且负责将变化通知给观察者。
观察者负责来执行这些变化。

一个被观察者接口
一个观察者接口
一个或多个被观察者实现类
一个或多个观察者实现类

请看如下代码结构：

被观察者接口

public interface MySubject {

    public void add(MyObserver observer);
    
    public void remove(MyObserver observer);
    
    public void notifyObservers();
}

观察者接口

public interface MyObserver {

    public void update(String name);
}

被观察者实现类

public class ConcreteSubject implements MySubject {
    
    private List<MyObserver> observers;
    private String name = "Max";
    
    public ConcreteSubject() {
        observers = new ArrayList<MyObserver>();
    }

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

    @Override
    public void remove(MyObserver observer) {
        observers.remove(observer);
    }
    
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++) {
            MyObserver ob = observers.get(i);
            ob.update(name);
        }
    }

}

观察者实现类

public class ConcreteObserver implements MyObserver {

    private String name;
    
    @Override
    public void update(String name) {
        this.name = name;
        print();
    }
    
    private void print() {
        System.out.println("Current name is : " + this.name);
    }

}

调用者

public class ObserverCaller {

    public static void main(String[] args) {
        ConcreteSubject sub = new ConcreteSubject();
        ConcreteObserver obs = new ConcreteObserver();
        
        sub.add(obs);
        sub.notifyObservers();
        
        sub.setName("Mike");
        sub.notifyObservers();
    }
}

那么，如何泛型化呢？

重点在于被观察者接口。

代码结构如下：

被观察者接口

public interface MySubject<T extends MyObserver> {

    public void add(T t);
    
    public void remove(T t);
    
    public void notifyObservers();
}

被观察者实现类

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

public class ConcreteSubject<T extends MyObserver> implements MySubject<T> {
    
    private List<T> observers;
    private String name = "Max";
    
    public ConcreteSubject() {
        observers = new ArrayList<T>();
    }

    @Override
    public void add(T t) {
        observers.add(t);
    }

    @Override
    public void remove(T t) {
        observers.remove(t);
    }
    
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++) {
            T ob = (T) observers.get(i);
            ob.update(name);
        }
    }

}

调用者

public class ObserverCaller {

    public static void main(String[] args) {
        ConcreteSubject<ConcreteObserver> sub = new ConcreteSubject<ConcreteObserver>();
        ConcreteObserver obs = new ConcreteObserver();
        
        sub.add(obs);
        sub.notifyObservers();
        
        sub.setName("Mike");
        sub.notifyObservers();
    }
}

不推荐使用Java的Observer类。可扩展性不好。