Java - Remplacement du type de retour de l'interface étendue lorsque le type de retour utilise des génériques pour ses propres types de paramètres de méthode

Une idée de base est maintenant de changer ce générique type de retour de GenericType dans Une Interface en GenericType dans l'Interface A1

Ce n'est pas possible, parce que Java Génériques sont invariantes. [1]

Que vous l'avez trouvé, vous ne pouvez pas avoir une interface de déclarer une méthode qui retourne GenericType<Object> et dans une sous-interface de remplacer la méthode pour retourner GenericType<String>: ce dernier type de retour n'est pas un sous-type de l'ancien. Et pour une bonne raison!

Vous avez essayé de

étendre indirectement la même interface avec les différents types génériques. Ce n'est malheureusement pas autorisé.

Il n'est en aucune façon pourrait éventuellement fonctionner: E. g. quel doit être le type de E dans public E set(int index, E element) dans une classe que mis en œuvre à la fois List<String> et List<Object>? Votre sous-classé interface produisent une semblable hybride: La valeur de retour de getAGenericType dans la sous-interface pour la mise en œuvre à la fois la GenericType<String> et la GenericType<Object> interface. Et comme nous l'avons vu, c'est impossible.

Le compilateur ne sait pas ce que vous allez faire avec le paramètre de type dans GenericType (bien qu'il pourrait théoriquement le savoir, il n'est pas). Si vous avez eu une variable de type GenericType<String> et affectée d'un GenericType<Object>vous pouvez très bien mettre un Long cas où un String est prévu, et obtenir une ClassCastException où vous ne vous attendez pas un.

Dans le doSomethingWith méthode de votre variable GenericType<? extends Object> aGenericType2 vous pouvez passer d'une chose: null. null est la seule référence de l'objet qui a un sous-type de ? extends Object. La limite inférieure type de ? extends Object est le type nullqui ne peut être exprimée en Java, et que de manière implicite existe comme le type de la null de référence.

[1] http://en.wikipedia.org/wiki/Covariance_and_contravariance_%28computer_science%29#Java

Je ne sais pas si c'est ce que vous attendez, mais Vous pouvez déclarer votre interface de quelque chose comme cela

public interface Interface <K extends Object> { ... }    

Alors que votre classe pourrait ressembler

public class InterfaceImpl extends Interface<String> { ... }

Je suis plusieurs années de retard à la fête, mais j'ai trouvé cette page en cherchant une question connexe, et aucune réponse n'a vraiment frappé sur la question centrale, qui je pense, mérite d'être précisée. Regardons un peu plus étoffé, exemple:

interface GenericType<D> {
D getAValue();
void doSomethingWith(D value);
}
class StringType implements GenericType<String> {
@Override
public String getAValue() {
return "Hello World";
}
@Override
public void doSomethingWith(final String value) {
System.out.println(value.length());
}
}
interface InterfaceA {
GenericType<? extends Object> getAGenericType();
}
interface InterfaceA1 extends InterfaceA {
@Override
GenericType<String> getAGenericType();
}
class AnActualA1 implements InterfaceA1 {
@Override
public GenericType<String> getAGenericType() {
return new StringType();
}
}
class LookAtTheInstance {
public static void method() {
InterfaceA1 a1 = new AnActualA1();
//'g1' is a StringType, which implements GenericType<String>; yay!
GenericType<String> g1 = a1.getAGenericType();
//Everything here is fine.
String value = g1.getAValue();
g1.doSomethingWith("Hello World");
//But if we upcast to InterfaceA???
InterfaceA a = (InterfaceA) a1;
//Note: a.getAGenericType() still returns a new StringType instance,
//which is-a GenericType<? extends Object>.
GenricType<? extends Object> g = a.getAGenericType();
//StringType.getAValue() returns a String, which is-an Object; yay!
Object object = g.getAValue();
//StringType.doSomethingWith() method requires a String as the parameter,
//so it is ILLEGAL for us to pass it anything that cannot be cast to a
//String. Java (correctly) prevents you from doing so.
g.doSomethingWith(new Object()); //Compiler error!
}
}

Sur le plan conceptuel, GenericType n'est PAS un GenericType, depuis un GenericType ne peut doSomethingWith() Cordes, tandis qu'un GenericType doit être en mesure de doSomethingWith() n'importe quel objet. GenericType est un compromis qui le compilateur permet de l'utiliser comme une "classe de base" pour tout GenericType où D est un Objet, mais seulement vous permet d'utiliser une référence de ce type, pour l'appel de méthodes qui sont de type sécurisé pour toute valeur d'exécution de '?' (comme getAValue(), dont la valeur de retour peut toujours être en toute sécurité cast d'un Objet depuis D-un Objet indépendamment de runtime type).

Il est difficile de dire ce que (le cas échéant) de l'affiche originale a été effectivement essayer de modéliser avec ce code, et en particulier la façon dont beaucoup de générique-ness de GenericType était vraiment nécessaire, mais peut-être l'héritage aurait du aller dans l'autre sens?

/**
* I can do something with instances of one particular type and one particular
* type only.
*/
interface GenericType<D> {
void doSomethingWith(D value);
}
/**
* I can do something with instances of any type: I am-a GenericType<String>
* because I can totally do something with a String (or any other kind of
* Object).
*/
interface NonGenericType extends GenericType<Object>, GenericType<String> {
@Override
void doSomethingWith(Object value);
}
interface StringHandlerFactory { //nee InterfaceA1
GenericType<String> getAGenericType();
}
/**
* I extend StringHandlerFactory by returning a NonGenericType (which is-a
* GenericType<String>, satisfying the interface contract, but also so much
* more).
*/
interface ObjectHandlerFactory extends StringHandlerFactory { //nee InterfaceA
@Override
NonGenericType getAGenericType();
}

L'inconvénient étant qu'il n'y a pas de bonne façon d'exprimer le compilateur java qui NonGenericType s'étend GenericType, même si en théorie, elle pourrait dans ce cas, puisque GenericType n'utilise jamais D une valeur de retour. Vous devez spécifier manuellement chaque GenericType que vous souhaitez étendre. 🙁