Looking for java Answers? Try Ask4KnowledgeBase
Looking for java Keywords? Try Ask4Keywords

Java Language Différentes manières d'implémenter une interface générique (ou d'étendre une classe générique)


Exemple

Supposons que l'interface générique suivante ait été déclarée:

public interface MyGenericInterface<T> {
    public void foo(T t);
}

Vous trouverez ci-dessous la liste des moyens possibles pour la mettre en œuvre.


Implémentation de classe non générique avec un type spécifique

Choisissez un type spécifique pour remplacer le paramètre de type formel <T> de MyGenericClass et implémentez-le, comme le montre l'exemple suivant:

public class NonGenericClass implements MyGenericInterface<String> {
    public void foo(String t) { } // type T has been replaced by String
}

Cette classe ne traite que de String , ce qui signifie que l'utilisation de MyGenericInterface avec des paramètres différents (par exemple, Integer , Object etc.) ne sera pas compilée, comme le montre l'extrait de code suivant:

NonGenericClass myClass = new NonGenericClass();
myClass.foo("foo_string"); // OK, legal
myClass.foo(11); // NOT OK, does not compile
myClass.foo(new Object()); // NOT OK, does not compile

Implémentation de classe générique

Déclarez une autre interface générique avec le paramètre de type formel <T> qui implémente MyGenericInterface , comme suit:

public class MyGenericSubclass<T> implements MyGenericInterface<T> {
    public void foo(T t) { } // type T is still the same
    // other methods...
}

Notez qu'un paramètre de type formel différent peut avoir été utilisé, comme suit:

public class MyGenericSubclass<U> implements MyGenericInterface<U> { // equivalent to the previous declaration
    public void foo(U t) { }
    // other methods...
}

Implémentation de la classe de type brute

Déclarez une classe non générique qui implémente MyGenericInteface tant que type brut (sans utiliser de générique du tout), comme suit:

public class MyGenericSubclass implements MyGenericInterface {
    public void foo(Object t) { } // type T has been replaced by Object
    // other possible methods
}

Cette méthode n'est pas recommandée, car elle n'est pas sécurisée à 100% à l'exécution, car elle mélange le type brut (de la sous-classe) avec les génériques (de l'interface), ce qui est également source de confusion. Les compilateurs Java modernes émettront un avertissement avec ce type d'implémentation, néanmoins le code - pour des raisons de compatibilité avec les anciennes JVM (1.4 ou antérieures) - sera compilé.


Toutes les méthodes énumérées ci-dessus sont également autorisées lorsque vous utilisez une classe générique en tant que super-type au lieu d'une interface générique.