Analysis of Getting Started with Java Generics

1. What are generics?

Generics actually means passing types as parameters. Generics allow programmers to use some types that are specified later when writing code. When instantiating the class, they will The desired types are passed as arguments to specify these types.

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 int type elements. We know that in java collection Any type of data can be added to the sequence table. How is this achieved? Here we first try to change the int type into 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 the object in the main method, you can add any type of data. However, when data needs to be taken out, because the returned type is Object, forced conversion is required 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, does it have to be forced to be forwarded every time before it can be received? Can it be avoided? 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 passed type can be stored in this object. Then when we take it out, we can clearly identify all the data in the object. They are all of this type, no need to force transfer. 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 perform forced type conversion

So what is the type of the corresponding object of MyArrayList here? Is it MyArrayList or something like that?

It can be seen here that the types of objects created by the instance are all MyArrayList, and the content in does not participate in the composition of generic types, then Where are the types inside? This requires understanding the working mechanism of generics.

2. How generics are 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 check for type errors at compile time and have no type information at runtime.

Generic compilation mechanism: erasure mechanism

During compilation, E in MyArrayList is erased into the Object type.

are all changed to MyArrayList type in the main method.

The above is the detailed content of Analysis of Getting Started with Java Generics. For more information, please follow other related articles on the PHP Chinese website!