Explication détaillée de l'exemple de code des génériques Java

Cet article présente principalement les connaissances pertinentes sur les génériques Java. A une très bonne valeur de référence. Jetons un coup d'œil avec l'éditeur

Tout d'abord, veuillez regarder le code suivant :

public class generictype {
 public static void main(String str[]) {
  Hashtable h =new Hashtable();
  h.put(1, "String类型");
  int a = (String) h.get(1);
  System.out.println(a);
 }
}
//执行结果
String类型
//如果我们将上述由红色标出的String改为int执行后结果如下(更改后编译没有错误):
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
 at genetictype.generictype.main(generic1.java:10)

Ce qui précède est ce qui a forcé la conversion de type . peut apporter une erreur typique, cependant, cette erreur ne peut pas être connue lors de la compilation, de sorte qu'une exception de conversion de type est levée après la vérification jvm pendant l'exécution.

Regardez le code suivant :

public class generictype { 
 public static void main(String str[]) {  
 Hashtable<Integer, String> h = new Hashtable<Integer, String>();
  h.put(1, "String类型");
  String a= h.get(1);
  System.out.println(a);
 }
}
//执行结果
string类型
//需要提出的是1.上述由红色标出的String如果改为int，在编译的时候会报错
   2.在h.get（1）前面不需要再进行强制类型转换。

Pour résumer, le rôle des génériques est :

1 Il est compilé lors de la vérification. sécurité des types (résoudre les erreurs pouvant être causées par une conversion de type forcée en Java), le compilateur a une mission énorme.

2. Améliorer le taux de réutilisation du code

Effacement de type :

L'effacement de type signifie que lorsque le compilateur compile le fichier .java, la classe Si le les paramètres génériques sont supprimés, les génériques ne seront pas visibles lorsque le jvm chargera le fichier de bytecode. Ce processus est appelé effacement de type.

Phénomènes liés à l'effacement de type :

(1) Les classes génériques n'ont pas le type de classe Class. Par exemple, il n'y a pas de List.class ou List.class, mais seulement List.class.

(2) Les Variables statiques sont partagées par toutes les instances d'une classe générique.

public class generictype 
{
 public static void main(String str[]){
  test1<String> t = new test1<String>();
  test1<Date> tt = new test1<Date>();
  System.out.println(t.a);
  System.out.println(tt.a);
 }
}
class test1<T>{
 static int a = 1;
}
//结果
1

(3) Les erreurs de paramètres de type générique ne peuvent pas être transmises via la Gestion des exceptions, car la gestion des exceptions est implémentée par jvm, et Le fichier bytecode chargé par jvm a effacé les caractéristiques génériques, ce qui illustre aussi indirectement la signification des génériques : l'erreur de type de paramètre a été trouvée lors de la compilation.

Le processus de base d'effacement de type est également relativement simple :

1. Remplacez les paramètres de type par la classe parent de niveau supérieur, qui est généralement Object , si une limite supérieure pour le paramètre de type est spécifiée, cette limite supérieure est utilisée.

2. Supprimez la déclaration de type qui apparaît, c'est-à-dire supprimez le contenu de <>.

Par exemple : la déclaration de la méthode T get() devient Object get(); Ensuite, vous devrez peut-être générer des méthodes de pont. En effet, la classe après avoir effacé le type peut manquer de certaines méthodes nécessaires. Par exemple, considérons le code suivant :

public class generictype {public static void main(String str[]) {
  test3 t =new test3();
   t.getT("11111");
 }
}
interface test2<T>{
 public T getT(T t);
}
class test3 implements test2<String>{
 public String getT(String t){
  return t;
 }
}
//类型擦除后的代码
public class generictype {
 public static void main(String str[]) {
  test3 t = new test3();
  t.getT("11111");
 }
 interface test2 {
  public Object getT(Object t);
 }
 class test3 implements test2 {
 public String getT(String T){
   return T }
 public Object getT(Object t) {
  return this.getT((String) t);
  }//如果没有这段代码，在类型擦除后test3没有重写接口test2的抽象方法，明显错误，因此编译器的巨大作用就是在这里帮忙生成了该方法，同时编译器也依靠该功能完成检错任务。
}

Classification des génériques : classes génériques, interfaces génériques, méthodes génériques, exceptions génériques

Classe générique

public class generictype {
 public static void main(String str[]) {
  test<Integer, String> t = new test<Integer, String>();
  t.put(1, "str1");
  t.put(2, "str2");
  System.out.println(t.get(1));
  System.out.println(t.get(2));
 }
}
class test<T, V> {
 public Hashtable<T, V> h = new Hashtable<T, V>();
 public void put(T t, V v) {
  h.put(t, v);
 }
 public V get(T t) {
  return h.get(t);
 }
}
//执行结果
str1
str2

Méthode polymorphe (méthode générique) : dans la fonction Définir les paramètres génériques avant le nom . Vous pouvez transmettre la liste des paramètres, le type de valeur de retour et le corps de la méthode)

public class generictype {
public <T> String getString(T obj){
 return obj.toString();
}
 public static void main(String str[]) {
  generictype g =new generictype ();//不需要类的泛型
  System.out.println(g.getString(1));
  System.out.println(g.getString(&#39;a&#39;));
  System.out.println(g.getString("a"));
 }
}
//执行结果
a
a

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!