Hériter d'une interface générique plusieurs fois tout en respectant la variance

Question

J'ai rencontré un problème en essayant de spécialiser une classe qui implémente une interface générique dont je voulais hériter de la même interface que la super classe, mais avec un argument de type plus spécifique . L'extrait suivant montre un exemple synthétique mais complet qui ne peut pas être compilé. Le commentaire contient le message d'erreur du compilateur Java.

interface Producer<T> { 
    T get(); 
} 

class NumberProducer implements Producer<Number> { 
    @Override 
    public Number get() { return null; } 
} 

// Producer cannot be inherited with different arguments: <java.lang.Integer> and <java.lang.Number> 
class IntegerProducer extends NumberProducer implements Producer<Integer> { 
    @Override 
    public Integer get() { return null; } 
} 

Au sens PECS, Producer<T> est un producteur , donc Producer<Integer>serait un sous-type de Producer<Number>, mais il n'y a aucun moyen de déclarer que dans la définition de Producer<T>. Java n'autorise pas IntegerProducer à hériter de NumberProducer et Producer<Integer> en même temps que IntegerProducer hériterait alors de Producer<Integer> et Producer<Number> en même temps.

Existe-t-il une approche standard de cette limitation, par ex. un modèle qui résout le même problème sans nécessiter ce type d'héritage?

Answer 1

Il suffit d'ajouter un paramètre à la super classe:

interface Producer<T> { 
    T get(); 
} 

class NumberProducer<T extends Number> implements Producer<T> { 
    @Override 
    public T get() { return null; } 
} 

class IntegerProducer extends NumberProducer<Integer> { // Implicit: implements Producer<Integer> 
    @Override 
    public Integer get() { return null; } 
} 

Answer 2

Si vous voulez vous assurer que T est un sous-type spécifique, vous pouvez utiliser

interface Producer<T extends Number> 

Je ne sais pas ce que reall du producteur est donc je dois deviner.

Mise à jour: Si je comprends bien, alors je dirais, vous devez déclarer une interface qui est un producteur. C'est simple.

De cette interface, je dériverais une nouvelle interface avec le type de base respecitve.

i.e. .:

interface Producer 
{ 
    base functions 
}; 


interface Newproducer<T extends Producer> 
{ 
}; 

Est-ce que vous aviez en tête?

Answer 3

Supposons que nous ayons une méthode simple gimme.

public static <T> T gimme(Producer<T> p) { return p.get(); } 

Dans le cadre de gimme ne sait rien T. Il peut s'agir de Number, Integer ou de tout autre type de référence. Ainsi, en raison de l'effacement, le compilateur émet un appel d'interface à Producer.get()Object plutôt que l'appel spécifique, par exemple, IntegerProducer.get()Integer. Tous les types qui implémentent Producer<T> avec T != Object implémentent également implicitement Producer.get()Object. Cette implémentation implicite est transmise à l'implémentation spécifique. Cela peut être NumberProducer.get()Number ou IntegerProducer.get()Integer, mais pas les deux. C'est pourquoi vous ne pouvez pas implémenter la même interface deux fois.

D'autres langues permettent cette variance via le site de définition, où Producer<Integer> est un sous-type de Producer<Number>, mais hélas, Java ne fonctionne pas. La solution de contournement commune est également de rendre NumberProducer générique.