Let's talk about the generic mechanism of Java

Interviewer: Tell me what the generic mechanism of Java is.

(Learning video sharing: java video tutorial)

Lite version answer

When developing Java, by using diamond syntax < >, Make a class, interface or method have a group of classes that accept a generic reference as a parameter. The generic class is ultimately defined by the rules in angle brackets. The generic class is usually represented by a capital letter, usually the letter T, and is later passed by the Java compiler During compilation, the generics will be erased, replaced according to the specific class used, and the class bytecode will be generated, so the generics are transparent to the Jvm.

Deluxe version answer

Generics were officially introduced in JDK1.5

Background of the introduction of generics in Java

Java collections allow multiple types to be put in , for example

    List list=new ArrayList();
    list.add("String");
    list.add(1024);

This was a common usage before JDK1.5. Even if it is placed under today's JDK, it is allowed. Then the usage of this collection will cause some problems. I am afraid that only the person who created the collection knows what types are placed in the collection. Other callers cannot determine it at all. In large projects, problems are very likely to occur. If the caller forcefully transfers an object in the collection, once the type is wrong , an error will be reported. This kind of error cannot be found in the compilation stage at that time, and can only be found when running. In order to solve similar problems, JDK introduced generics.

Generic types

After the introduction of generics, it is possible to check whether the type meets the requirements during the compilation phase. To a large extent, blind type conversion is eliminated. Generics mainly work in the compiler. After compilation, the JVM cannot perceive generics when it is running. Generics are divided into ordinary generics and wildcard generics.

1. Ordinary generics

As the name suggests, this type of generics supports passing in any type when calling, but when calling, the generics on the left and right sides of the equal sign must be consistent. The diamond on the right side of JDK1.7 can be omitted.

class Test<T>{...} //声明时
Test<Integer> test = new Test<Integer>(); //调用时
Test<Integer> test = new Test(); //1.7调用时

3. Bounded generics

<?>//无界泛型，任意类型都匹配
<T extends ClassA>//有界泛型 - 继承自某父类
<T extends InterfaceB>//有界泛型 - 实现某接口
<T extends ClassA & InterfaceB & InterfaceC ... >//有界泛型 - 多重边界
<T super ClassC>//有界泛型 - 指定类父类

Generic erasure

As mentioned just now, generics only work when writing code and compiling, and Jvm loads classes The runtime is invisible and transparent because the compiler erases generics when compiling. To put it simply and loosely, it means: remove the <> angle brackets on the class or method, and follow the rules in the angle brackets. Change to a specific class, so the Jvm runtime does not know that there have been generics in this code before. This is done for compatibility. As mentioned earlier, generics were only introduced in JDK1.5. In this way, even if generics are introduced, now Some JVMs do not need major changes, they only need to change the compiler. For this kind of syntax that the compiler can perceive, but the virtual machine cannot, people call this syntax sugar (suger). The compiler After desugering, the dry information is obtained and handed over to the virtual machine for execution.

(Recommended graphic tutorial: java introductory tutorial)

Generic erasure mechanism

//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;
    ...
}

When generics are used as input parameters of a method, After erasing, it is replaced with the lower bound of a wildcard generic, such as the add method

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

When the generic is used as a return parameter of a method, it is replaced with the upper bound of a wildcard generic after erasure, such as the get method

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

No matter how much we talk about generic type erasure, no matter how many blogs we read, the official definition is not as accurate as the official definition. Here is a section of Oracle’s official document on type erasure

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.

For more interview questions, please click: java interview questions and answers

The above is the detailed content of Let's talk about the generic mechanism of Java. For more information, please follow other related articles on the PHP Chinese website!