Tout ce que nous savons est "Toutes les instances d'une quelconque classe d'actions de la même java.lang.Class l'objet de ce type de classe"
e.g)
Student a = new Student();
Student b = new Student();
Ensuite, a.getClass() == b.getClass() est vrai.
Supposons maintenant
Teacher t = new Teacher();
sans les génériques ci-dessous est possible.
Class studentClassRef = t.getClass();
Mais c'est mal connaître ..?
e.g) public void printStudentClassInfo(Class studentClassRef) {} peut être appelée avec Teacher.class
Ceci peut être évité par l'utilisation de médicaments génériques.
Class<Student> studentClassRef = t.getClass(); //Compilation error.
Maintenant, qu'est-ce que T ?? T est le type des paramètres (aussi appelés variables de type); délimités par des crochets (<>), suit le nom de la classe.
e.g) class name<T1, T2, ..., Tn>
Donc, Class<T> représente un objet de classe de classe spécifique de type 'T'.
Supposons que vos méthodes de la classe a à travailler avec type inconnu paramètres comme ci-dessous
/**
* Generic version of the Car class.
* @param <T> the type of the value
*/
public class Car<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
Ici T peut être utilisé en tant que String type de CarName
OU T peut être utilisé en tant que Integer type de modelNumber,
OU T peut être utilisé en tant que Object type valide voiture instance.
Maintenant, voici ce qui précède est la simple POJO qui peuvent être utilisés de la même manière lors de l'exécution.
Méthodes Génériques
Méthodes génériques sont des méthodes qui introduisent leurs propres paramètres de type. Ceci est similaire à la déclaration d'un type générique, mais le type du paramètre de la portée est limitée à la méthode où il est déclaré. Statiques et non statiques et méthodes génériques sont autorisés, ainsi que les génériques de constructeurs de classe.
La syntaxe d'une méthode générique comprend un paramètre de type, à l'intérieur des crochets, et apparaît avant le retour de la méthode type. Pour les méthodes génériques, le paramètre du type d'article doit apparaître avant le retour de la méthode type.
class Util {
// Generic static method
public static <K, V, Z, Y> boolean compare(Pair<K, V> p1, Pair<Z, Y> p2) {
return p1.getKey().equals(p2.getKey()) &&
p1.getValue().equals(p2.getValue());
}
}
class Pair<K, V> {
private K key;
private V value;
}
Ici, <K, V, Z, Y> est la déclaration des types utilisés dans les arguments de la méthode qui devrait, avant que le type de retour qui est - boolean ici.
Dans le ci-dessous; la déclaration de type <T> n'est pas requis au niveau de la méthode, car il est déjà déclaré au niveau de la classe.
class MyClass<T> {
private T myMethod(T a){
return a;
}
}
Mais ci-dessous est faux, où K, V, Z, Y sont des variables de type de classe différente Pair
class Util <K, V, Z, Y>{
// Generic static method
public static boolean compare(Pair<K, V> p1, Pair<Z, Y> p2) {
return p1.getKey().equals(p2.getKey()) &&
p1.getValue().equals(p2.getValue());
}
}
D'AUTRES SCÉNARIOS SONT
class MyClass<T> {
//Type declaration <T> already done at class level
private T myMethod(T a){
return a;
}
//<T> is overriding the T declared at Class level;
//So There is no ClassCastException though a is not the type of T declared at MyClass<T>.
private <T> T myMethod1(Object a){
return (T) a;
}
//Runtime ClassCastException will be thrown if a is not the type T (MyClass<T>).
private T myMethod1(Object a){
return (T) a;
}
// No ClassCastException
// MyClass<String> obj= new MyClass<String>();
// obj.myMethod2(Integer.valueOf("1"));
// Since type T is redefined at this method level.
private <T> T myMethod2(T a){
return a;
}
// No ClassCastException for the below
// MyClass<String> o= new MyClass<String>();
// o.myMethod3(Integer.valueOf("1").getClass())
// Since <T> is undefined within this method;
// And MyClass<T> don't have impact here
private <T> T myMethod3(Class a){
return (T) a;
}
// ClassCastException for o.myMethod3(Integer.valueOf("1").getClass())
// Should be o.myMethod3(String.valueOf("1").getClass())
private T myMethod3(Class a){
return (T) a;
}
// Class<T> a :: a is Class object of type T
//<T> is overriding of class level type declaration;
private <T> Class<T> myMethod4(Class<T> a){
return a;
}
}
Et enfin la méthode Statique doit toujours explicite <T> déclaration; Il l'habitude de dériver de la classe de niveau Class<T>. C'est en raison du niveau de la Classe T est lié avec instance.
