java泛型观察者模式？

Question

我知道关于这个一般主题有很多（！）Q/A； 但还没有能够解决我的具体方法。

我从 Odersky 的 Scala 示例中改编了这段代码，该示例显示了相互递归的泛型类型，以显示 Observer 和 Observed 之间的双向链接能力。

在 Subject::publish() 中，当我向所有观察者广播事件时，即使我的类型是 Subject<S,O>，并且目标观察者的类型是 <S,O>，因此也是它的 notify 方法； 我收到一个类型错误，

Observer<S,O> 类型中的方法 notify(S) 不适用于参数 (Subject<S,O>)

除非我显式地将传递的参数强制转换为 notify()。

obs.notify((S) this ); 类型看起来是正确的，但编译器不同意（！）。

可能有些愚蠢，但它让我望而却步。 TIA

abstract class Subject< S extends Subject<  S, O >,
                        O extends Observer< S, O > > {
    private final List< O > observers = new ArrayList<O>();
    void subscribe( O obs ) { observers.add( obs ); }
    void publish() {
        for ( final O obs : observers )
            // TThe method notify(S) in the type Observer<S,O> is not applicable for the arguments (Subject<S,O>)
            obs.notify( this ); // (S)this   ??
    }
}
//-------------------------------------------------------------
abstract class Observer< S extends Subject<  S, O >,
                         O extends Observer< S, O > > {
    abstract void notify( S sub );
}
//-------------------------------------------------------------
class Sensor extends Subject< Sensor, Display > {
    double value = 0.0;
    String name  = "";
    Sensor(String nm) { name = nm; }
    
    void changeValue( final double v ) {
        value = v;
        publish();
    }
    public String toString() { return "Sensor:" + name; }
}

class Display extends Observer< Sensor, Display > {
    void notify( Sensor sub ) {  // Note typed argument!
        System.out.println( sub  + " has value " + sub.value );
    }
}
//-------------------------------------------------------------
public class SubjectObserver {
    public static void main( final String[] notUsed ) {
        final Display o = new Display();
        final Sensor  s = new Sensor("Temperature");
        s.subscribe( o );
        s.changeValue( 1 );
    }
}

Answer 1

你几乎做对了！

自有界（或递归）类型声明暗示了几个微妙的细微差别。 鉴于您的观察者声明，我们可以声明：

abstract class Observer<S extends Subject<S, O>, O extends Observer<S, O>> {
    abstract void notify(S sub);
}

1. 构造<S extends Subject<S, O>确保只允许类型Subject<S, O>子类型作为类型参数，这意味着notify(S sub)不能接受Subject类本身，而只能接受它的后代。
2. 它确保子类型和 Subject 的实例化之间的继承关系是Child extends Subject<Child, O>的形式Child extends Subject<Child, O>这意味着像Sensor extends Subject<NotASensorItself, O>这样的子类型是不可能的（这就是你真正想要的）

---

说到Subject#publish方法，通过使用THIS你有效地强迫观察者接受不符合声明界限（ S ≠ Subject<S, O> ）的Subject （父），因此你得到了错误：

void publish() {
    for (final O obs : observers)
        obs.notify(this); <<< Here only S are acceptable
}
    

实际上，当您希望obs.notify(XXX)接受Clild实例时，这样做的选项之一是直接传递该引用以及来自Clild的方法调用：

void publish(S subject) {
    for (final O obs : observers)
        obs.notify(subject);
}

和传感器实现：

class Sensor extends Subject<Sensor, Display> {
    ...
    void changeValue(final double v) {
        value = v;
        publish(this); << Here it passes itself, so now it conforms the bound for `S`
    }
}

一些可能有助于理解令人费解的递归类型的链接：

1. http://www.angelikalanger.com/GenericsFAQ/FAQSections/TypeParameters.html#FAQ106
2. https://medium.com/@hazraarka072/fluent-builder-and-powering-it-up-with-recursive-generics-in-java-483005a85fcd