What are generics? - Introduction to Generics

1. What are generics?

Generics are actually passing types as parameters. Generics allow programmers to use some types that are specified later when writing code, and specify these types by passing the desired types as parameters when instantiating the class.

Why introduce generics?

For example: implement a sequence table by yourself

public class MyArrayList {
    
    
    public int[] elem;
    public int usedSize;

    public MyArrayList() {
    
    
        this.elem = new int[10];
    }
    // add方法
    public void add(int val) {
    
    
        // 暂时不考虑扩容问题，这里只是为了讲泛型
        elem[usedSize++] = val;
    }
    // get方法
    public int get(int pos) {
    
    
        return elem[pos];
    }
}

It can be seen here that when using the above custom sequence table, we can only add elements of type int . We know the sequence table in the java collection and can add any type of data. How to achieve it?
Here we first try to change the int type to the Object type, so that we can guarantee that any type can be passed in.

public class MyArrayList {
    
    
    public Object[] elem;
    public int usedSize;

    public MyArrayList() {
    
    
        this.elem = new Object[10];
    }
    // add方法
    public void add(Object val) {
    
    
        // 暂时不考虑扩容问题，这里只是为了讲泛型
        elem[usedSize++] = val;
    }
    // get方法
    public Object get(int pos) {
    
    
        return elem[pos];
    }
}

When adding data to an object in the main method, you can add any type of data. However, when the data needs to be taken out, because the object type is returned, it needs to be casted to receive it with the corresponding type, which is very troublesome.

public static void main(String[] args) {
    
    
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add("hello");
        int array1 = (int)myArrayList.get(0);
        String array2 = (String)myArrayList.get(1);
    }

So the question is, do you have to force the transfer every time to receive it, and can you not force the transfer? At this time, we thought that when creating an instance object, we can pass the desired type as a parameter , so that all the data of the incoming type can be stored in the object, then when we take it out, we can clarify all the data in the object. All are of this type, and no forced conversion is required. This introduces generics.

public class MyArrayList<E> {
    
    
	// 在编写程序时，不指定具体的类型，而用<E>这里的E来暂时代替
    // 具体的类型在实例化对象时传入
    public E[] elem;
    public int usedSize;

    public MyArrayList() {
    
    
    	// 这里的写法不是特别准确，应该用反射机制，这里先这样写
        this.elem = (E[])new Object[10];
    }
    // add方法
    public void add(E val) {
    
    
        // 暂时不考虑扩容问题，这里只是为了讲泛型
        elem[usedSize++] = val;
    }
    // get方法
    public E get(int pos) {
    
    
        return elem[pos];
    }
}

public static void main(String[] args) {
    
    

        MyArrayList<Integer> myArrayList1 = new MyArrayList<>();
        myArrayList1.add(1);
        myArrayList1.add(3);
        // myArrayList1.add("world");// 这里会报错，因为传入的数据不是指定的类型，所以泛型还有自动对类型进行检查的作用
        int I1 = myArrayList1.get(0);
        
        MyArrayList<String> myArrayList2 = new MyArrayList<>();
        myArrayList2.add("hello");
        myArrayList2.add("world");
        String s1 = myArrayList2.get(0);
    }

This ensures that any type of data can be passed in, and there is no need to force it when taking it out!
The meaning of generics:
1. Automatically check the type
2. Automatically cast the type

So what is the type of the corresponding object of MyArrayList here? Is it MyArrayList<Integer> or something?

It can be seen here that the objects created by the instance are of MyArrayList type, and the content in <> does not participate in the composition of generic types, so where is the type in <>? This is to understand the working mechanism of generics.

2. How are generics compiled?

An important difference between arrays and generics is how they enforce type checking. Specifically, arrays store and check type information at runtime . However, generics are checked for type errors at compile time and have no type information at runtime .

Generic compilation mechanism: erasure mechanism

At compile time, E in MyArrayList is erased to be of type Object.

In the main method are wiped into MyArrayList type.

Reference: create generic array in java