如何改进基于Java泛型实现观察者模式的两类方案？

针对你用Java泛型实现观察者模式遇到的两个方案的问题，下面逐个改进并分析：

方案一的改进 #

原方案里的getIdentity和Observable的类型参数可以通过自限定泛型优化，让类型参数直接绑定子类本身，去掉冗余的抽象方法：

public interface Observer<T extends Observable<T>> {
    void update(T observable);
}

public abstract class Observable<T extends Observable<T>> {
    private final List<Observer<T>> observerList = new ArrayList<>();

    public void addObserver(Observer<T> observer) {
        observerList.add(observer);
    }

    @SuppressWarnings("unchecked")
    public void notifyObservers() {
        for (Observer<T> observer : observerList) {
            // 自限定泛型保证T就是当前子类类型，此转换安全
            observer.update((T) this);
        }
    }
}

子类实现仍保持class Data extends Observable<Data>和class DataObserver implements Observer<Data>，这里的(T) this是可控的unchecked cast——因为子类继承时必须指定T为自身，编译期能保证类型匹配，用@SuppressWarnings("unchecked")标注即可消除警告。

优化后去掉了多余的getIdentity，类型参数的作用也更明确：强制子类将自身作为泛型参数传入，保证观察者和被观察者的类型强绑定。

方案二的改进 #

方案二的核心问题是getIdentity的泛型方法设计不合理：泛型方法的类型参数T由调用方决定，运行时无法验证this是否属于T类型，所以unchecked cast警告无法从根源消除（只能用@SuppressWarnings压制）。另外，观察者列表用Observer<? extends Observable>会导致类型不安全——比如你可以把Observer<OtherObservable>加到DataObservable的列表中，调用update时会触发ClassCastException。

如果要勉强优化方案二的类型安全性，可以将观察者列表改为Observer<? super Observable>，但这样update方法的参数会退化为Observable，失去泛型的精确匹配能力，违背你用泛型的初衷。因此方案二的设计本身存在先天缺陷，不推荐作为最优解。

方案对比与优劣 #

• 方案一（自限定泛型版）：类型安全性最高，编译期就能检查观察者和被观察者的类型匹配，逻辑清晰，虽然有一个可控的unchecked cast，但属于自限定泛型的常规写法，可读性和维护性更好，完全符合你聚焦泛型理解的需求。
• 方案二：去掉Observable的类型参数看似简洁，但牺牲了核心的类型安全性，泛型方法的设计存在逻辑漏洞，运行时存在类型转换风险，仅适合不需要精确类型匹配的场景。

更优雅的实现方式 #

如果想要完全贴合泛型设计规范，同时保留精确类型匹配，推荐基于方案一优化的最终版本，去掉冗余代码的同时保证类型安全：

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

public interface Observer<T> {
    void update(T observable);
}

public abstract class Observable<T extends Observable<T>> {
    private final List<Observer<T>> observers = new ArrayList<>();

    public void addObserver(Observer<T> observer) {
        observers.add(observer);
    }

    @SuppressWarnings("unchecked")
    protected void notifyObservers() {
        for (Observer<T> observer : observers) {
            observer.update((T) this);
        }
    }
}

// 子类示例
public class Data extends Observable<Data> {
    private String value;

    public void setValue(String value) {
        this.value = value;
        notifyObservers();
    }

    public String getValue() {
        return value;
    }
}

public class DataObserver implements Observer<Data> {
    @Override
    public void update(Data observable) {
        System.out.println("数据更新：" + observable.getValue());
    }
}

这个实现中，notifyObservers的类型转换是安全的——子类必须遵循自限定泛型规则，将自身作为类型参数传入，编译期可确保类型一致性，@SuppressWarnings只是明确告知编译器我们确认此转换无风险。

内容的提问来源于stack exchange，提问作者bhansen