Parlons du mécanisme générique de Java

Intervieweur : Parlez-moi du mécanisme générique de Java.

(Partage vidéo d'apprentissage : Tutoriel vidéo Java)

Réponse de la version Lite

Lors du développement de Java, en utilisant la syntaxe diamant 338bf99be1152e2f6ccb30128dac1522 sur la classe ou la méthode, et suivez les règles dans les crochets. Passez à une classe spécifique, donc le Jvm. Le runtime ne sait pas qu'il y a eu des génériques dans ce code auparavant. Ceci est fait pour des raisons de compatibilité. Comme mentionné précédemment, les génériques n'ont été introduits que dans JDK1.5. De cette façon, même si des génériques sont introduits, certaines JVM n'ont pas besoin de majeures. changements, il leur suffit de changer de compilateur. Pour ce type de syntaxe que le compilateur peut percevoir, mais que la machine virtuelle ne peut pas, les gens appellent cette syntaxe sugar (suger). Après désugération, les informations sèches sont obtenues et transmises à. la machine virtuelle pour l'exécution.

(Tutoriel graphique recommandé : Tutoriel d'introduction à Java)

Mécanisme d'effacement générique

//Pair的泛型
public class Pair<T> {

    private T mFirst;
    private T mSecond;

    public T getmFirst() {
        return mFirst;
    }

    public void setmFirst(T mFirst) {
        this.mFirst = mFirst;
    }

    public T getmSecond() {
        return mSecond;
    }

    public void setmSecond(T mSecond) {
        this.mSecond = mSecond;
    }
}

//Pair的原始类型
//无论何时定义一个泛型类型，都会自动提供一个相应的 原始类型
public class Pair {

    private Object mFirst;
    private Object mSecond;

    public Object getFirst() {
        return mFirst;
    }

    public void setFirst(Object mFirst) {
        this.mFirst = mFirst;
    }

    public Object getSecond() {
        return mSecond;
    }

    public void setmSecond(Object mSecond) {
        this.mSecond = mSecond;
    }
}

//如果调用Pair<T extends String>编译擦除后得到如下=
class Pair{
    private String mFirst;
    private String mSecond;
    ...
}

Lorsque des génériques sont utilisés comme paramètres d'entrée d'une méthode, après l'effacement , il est remplacé par la borne inférieure d'un générique générique, tel que la méthode add

public static void insertElements(List<? super A> list){
    //Add进来的都是层级“小于等于”A的，也就是下界
    list.add(new A());
    list.add(new B());
    list.add(new C());
}

Lorsqu'un générique est utilisé comme paramètre de retour d'une méthode, il est remplacé par la borne supérieure d'un générique générique après effacement, comme la méthode get

public void processElements(List<? extends A> elements){
   //for循环挨个get list 里的数据，都当做A，也就是都当做上界
   for(A a : elements){
      System.out.println(a.getValue());
   }
}

Peu importe combien vous parlez d'effacement de type générique, peu importe le nombre de blogs que vous lisez, la définition officielle n'est pas aussi précise que la définition officielle. Document officiel d'Oracle sur l'effacement de type

Type Erasure
Generics were introduced to the Java language to provide tighter type checks at compile time and to support generic programming. To implement generics, the Java compiler applies type erasure to:
Replace all type parameters in generic types with their bounds or Object if the type parameters are unbounded. The produced bytecode, therefore, contains only ordinary classes, interfaces, and methods.Insert type casts if necessary to preserve type safety.Generate bridge methods to preserve polymorphism in extended generic types.Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.

Pour plus de questions d'entretien, veuillez cliquer sur : questions et réponses d'entretien Java

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!