Java's generic type erasure is the mechanism by which the compiler erases specific type information when processing generics. 1. Java will remove generic information during compilation, so that List and List are regarded as the same type at runtime; 2. This design is to be compatible with versions before Java 1.5; 3. Generic types will be replaced with boundary types, such as T is replaced with Object, T extends Number is replaced with Number, and the compiler inserts type conversion to ensure security; 4. Type erasure causes problems such as inability to create generic arrays, inability to check generic types with instanceof, and signature conflicts of different generic methods; 5. You can obtain parent-class generic information by reflection or save generics using anonymous internal classes to bypass restrictions, such as Gson parsing generics using TypeToken; 6. Understanding type erasure helps avoid traps in generic use and understand framework design principles.

Type Erasure for Java is a key mechanism for Java compilers to handle generics. Simply put, it refers to Java "erase" generic information during compilation, and no longer keep records of specific type parameters at runtime . This means that List<string></string> and List<integer></integer> are actually the same type at runtime.

Why is this designed? Mainly to maintain compatibility with older versions of Java (no generics before 1.5). But this also brings some restrictions and things to pay attention to.

The basic principle of type erasing

Java generics were introduced in Java 5, and in order to enable new code to coexist with old code, Java uses a type erase mechanism. Its basic rules include:

• Generic types will be replaced with their boundary types after compilation , such as T being replaced with Object .
• If there is a limitation like <t extends number></t> , then T will be replaced with Number .
• The compiler inserts type conversion code when necessary to ensure type safety.

For example:

 List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);

After compilation, the actual bytecode becomes:

 List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

You can see that the generic information is erased and replaced by casting.

Impact of Type Erase

Since there is no generic information at runtime, this leads to some common restrictions or problems we have:

• Generic arrays cannot be created : For example, new T[10] is not allowed because the runtime does not know what T is.

• You cannot use instanceof to determine generic types : for example, if (list instanceof List<String>) is illegal.

• Method signature conflict : If the two methods are just generics, they will lead to compilation errors. For example:

   public void method(List<String> list) {}
  public void method(List<Integer> list) {} // Compilation failed, method signature is repeated

These limitations all stem from the fact that Java generics only exist in the compilation stage .

How to bypass some limitations of type erasing?

Although Java erases the types, we can obtain some generic information in some ways:

• Get generic information in the parent class by reflection : suitable for when subclasses inherit a parent class with generics.

   class MyClass extends ArrayList<String> {}
  
  ParameterizedType type = (ParameterizedType) MyClass.class.getGenericSuperclass();
  Type[] types = type.getActualTypeArguments(); // Get String.class

• Save generic information using anonymous internal classes : This is how many frameworks (such as Gson) use them to parse generics.

   Type type = new TypeToken<List<String>>(){}.getType();

  This approach takes advantage of the ability of anonymous classes to retain their generic information when compiled.

  ---

  Let's summarize

  Type erasure is a compromise solution for Java to implement generics, bringing compatibility while sacrificing some flexibility. Understanding it will help avoid getting stuck in generic use and can better understand some of the design ideas of the underlying framework.

  Basically that's it. If you encounter a strange problem when writing generic code, it is likely that type erasing is "making trouble".

  The above is the detailed content of What is type erasure in Java generics?. For more information, please follow other related articles on the PHP Chinese website!