Detailed explanation of Java generics related knowledge (with code)-javaTutorial-php.cn

The content of this article is a detailed explanation of relevant knowledge about Java generics (with code). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

I think everyone is very familiar with the use of generics, but they may not be very clear about details such as type erasure and boundary expansion, so this article will focus on explaining them; in addition, understanding of generics can actually It can be seen that the generation logic of a language feature is also very helpful for our daily development;

1. Why do generics appear

First of all, generics It is not a language feature of Java, it is a feature that was not supported until JDK1.5 (the specific differences will be discussed later); so what was done before generics appeared?

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

Copy after login

As shown in the above code, we need to remember what we put in the collection, and then force it when we take it out; this also postpones this type conversion error to runtime, that is Trouble is not yet safe, so generics appear;

Usage scenarios: generic classes, generic interfaces, generic methods;

public class Test public interface Test public  void test(T t)

Copy after login

two , What kind of problems will generics bring

As mentioned above, generics are not a feature that Java has from the beginning, so when you want to add generics later, you must be compatible In previous versions, the compromise solution that Sun came up with wastype erasure; this means that generic information only exists during compilation, and all generic information is erased during runtime. I don’t think so;

List list1 = new ArrayList<>(); List list2 = new ArrayList<>(); System.out.println(list1.getClass()); System.out.println(list2.getClass() == list1.getClass());

Copy after login

// Print:
class java.util.ArrayList
true

You can seeListandListare actually the same at runtime, they are allclass java.util.ArrayList; so when using generics, you need to keep in mind thatthere are no generics at runtime Type information, and it is impossible to obtain any information about parameter types; so any operation that needs to obtain the runtime type is not supported by generics!

1. Type parameters cannot be instantiated with basic types

new ArrayList(); // error new ArrayList(); // correct

Copy after login

Because type erasure will erase it to its upper bound, which isObject; The direct parent class of Java's 8 basic types isNumber, so basic types cannot use basic types to instantiate type parameters, but must use basic type wrapper classes;

2. Cannot be used for runtime type checking

t instanceof T // error t instanceof List // error t instanceof List // error t instanceof List // correct

Copy after login

But you can useclazz.isInstance();to compensate;

3. Type instances cannot be created

T t = new T(); // error

Copy after login

You can also useclazz.newInstance();to compensate;

4. Cannot be staticized

private static T t; // error private T t; // correct private static List list; // error private static List list; // correct private static List list; // correct // e.g. class Test { private T t; public void set(T arg) { t = arg; } public T get() { return t; } }

Copy after login

Because static variables are shared in classes, and generic types are undefined, generics cannot be made static; but when they are non-static, the compiler can infer them based on the contextT## What is #, for example:

Test l = new Test(); System.out.println(l.get()); l.set("123"); System.out.println(l.get()); // javap -v 反编译 12: invokevirtual #15 // Method JDK/Test14_genericity$Test.get:()Ljava/lang/Object; 15: invokevirtual #16 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V 18: aload_1 19: ldc #17 // String 123 21: invokevirtual #18 // Method JDK/Test14_genericity$Test.set:(Ljava/lang/Object;)V 24: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream; // --------------------------- Test l = new Test(); System.out.println(l.get()); l.set("123"); System.out.println(l.get()); // javap -v 反编译 12: invokevirtual #15 // Method JDK/Test14_genericity$Test.get:()Ljava/lang/Object; 15: invokevirtual #16 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V 18: aload_1 19: bipush 123 21: invokestatic #17 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

Copy after login

According to the above code, you can clearly see the compiler’s derivation of non-static types;

In addition List and List ; the reason why it is correct still because the compiler can determine correctness of type conversion during compilation;

5. Instances of generic classes cannot be thrown or captured

catch (T t) // error class Test extends Throwable // error

Copy after login

Because runtime class information is needed when catching exceptions and the inheritance relationship of the exception is determined, instances of generic classes cannot be thrown or captured;

6. Overloading as a parameter is not allowed

void test(List list) void test(List list)

Copy after login

Because the generic information is erased during runtime, the signatures of the two overloaded methods are exactly the same;

7 . Unable to create a generic array

I think this is the most important point. For an introduction to arrays, please refer to Array related;

List[] lists = new ArrayList[10]; // error List[] lists1 = (List[]) new ArrayList[10]; // correct

Copy after login

The main reason why a generic array cannot be created:

Arrays are covariant, while generics are immutable;
The
Classinformation of the array is running It is created dynamically, and generic class information cannot be obtained at runtime;

According to the above explanation, we can see the general idea of the so-called erasure compensation or correction after erasure. They all use additional methods to inform the runtime of type information, which can be recorded in local variables or the exact type of specified parameters (

Array.newInstance(Class componentType, int length)) ;

3. Boundary expansion

Based on security considerations, Java generics are immutable (to avoid type conversion errors when retrieving data);