Problème avec le modèle Observateur et les génériques en Java

Question

J'ai créé une interface Observer générique et une classe Observable, mais je ne peux pas compiler ma classe en raison de problèmes génériques. Je ne sais pas précisément pourquoi ce que j'essaie de faire est interdit. Le code suivant:

public class Observable<U> { 

    private List<Observer<Observable<U>, U>> _observers = 
      new ArrayList<Observer<Observable<U>, U>>(); 

    public void addObserver(Observer<? extends Observable<U>, U> obs) { 
     if (obs == null) { 
      throw new IllegalArgumentException(); 
     } 
     if (_observers.contains(obs)) { 
      return; 
     } 
     _observers.add(obs); // This line does not compile 
    } 

    public void notifyObservers(U data) { 
     for (Observer<? extends Observable<U>, U> obs : _observers) { 
      // After correction of the list declaration, this line will not compile 
      obs.update(this, data); 
     }   
    } 
} 

interface Observer<T, U> { 
    public void update(T entity, U arg); 
} 

Answer 1

Essayez ceci:

public class Observable<U> { 

     private List<Observer<Observable<U>, U>> _observers = 
       new ArrayList<Observer<Observable<U>, U>>(); 

     public void addObserver(Observer<Observable<U>, U> obs) { 
      if (obs == null) { 
       throw new IllegalArgumentException(); 
      } 
      if (_observers.contains(obs)) { 
       return; 
      } 
      _observers.add(obs);   } 

     public void notifyObservers(U data) { 
      for (Observer<? super Observable<U>, U> obs : _observers) { 
       obs.atualizar(this, data); 
      } 
     } 
    } 

    interface Observer<T, U> { 
     public void atualizar(T entity, U arg); 
    } 

expliquer ici le problème sous-jacent, les médicaments génériques sont Forci un downcast explicite. Donc, vous ne pouvez pas prendre 'Observable' pour n'importe quelle implémentation de U et le mettre dans une collection, parce que cette collection est définie comme prenant un type spécifique de U, pas n'importe quoi.

Pour ce type de cas d'utilisation, les génériques ont des limites, et il se peut que vous ne puissiez pas accomplir ce que vous voulez de manière sécurisée.

EDIT: Cela fonctionnerait-il pour vous?

public class Observable<U> { 

     private List<Observer<U>> _observers = 
       new ArrayList<Observer<U>>(); 

     public void addObserver(Observer<U> obs) { 
      if (obs == null) { 
       throw new IllegalArgumentException(); 
      } 
      if (_observers.contains(obs)) { 
       return; 
      } 
      _observers.add(obs);   } 

     public void notifyObservers(U data) { 
      for (Observer<U> obs : _observers) { 
       obs.atualizar(this, data); 
      } 
     } 
    } 

    interface Observer<U> { 
     public void atualizar(Observable<U> entity, U arg); 
    } 

Answer 2

Changer votre définition de _observers à ceci:

private List<Observer<? extends Observable<U>, U>> _observers = 
     new ArrayList<Observer<? extends Observable<U>, U>>(); 

Si vous souhaitez autoriser les sous-classes, vous devez préciser dans la déclaration, non seulement à l'endroit que vous l'utilisez