¿Qué son los genéricos? - Introducción a los Genéricos

1. ¿Qué son los genéricos?

Los genéricos en realidad pasan tipos como parámetros. Los genéricos permiten a los programadores usar algunos tipos que se especifican más adelante al escribir código, y especificar estos tipos pasando los tipos deseados como parámetros al instanciar la clase.

¿Por qué introducir genéricos?

Por ejemplo: implemente una tabla de secuencia usted mismo

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];
    }
}

Aquí se puede ver que cuando usamos la tabla de secuencia personalizada anterior, solo podemos agregar elementos de tipo int . Conocemos la tabla de secuencia en la colección java y podemos agregar cualquier tipo de datos. ¿Cómo lograrlo?
Aquí primero tratamos de cambiar el tipo int al tipo Object, para que podamos garantizar que se puede pasar cualquier tipo.

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];
    }
}

Al agregar datos a un objeto en el método principal, puede agregar cualquier tipo de datos. Sin embargo, cuando es necesario sacar los datos, porque se devuelve el tipo de objeto, es necesario convertirlos para recibirlos con el tipo correspondiente, lo cual es muy problemático.

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);
    }

Entonces, la pregunta es, ¿tiene que forzar la transferencia cada vez para recibirla y no puede forzar la transferencia? En este momento, pensamos que al crear un objeto de instancia, podemos pasar el tipo deseado como parámetro , para que todos los datos del tipo entrante puedan almacenarse en el objeto, luego cuando lo saquemos, podemos aclarar todo los datos en el objeto Todos son de este tipo y no se requiere conversión forzada. Esto introduce genéricos.

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);
    }

¡Esto asegura que se pueda pasar cualquier tipo de datos, y no hay necesidad de forzarlos al sacarlos!
El significado de los genéricos:
1. Comprueba automáticamente el tipo
2. Emite automáticamente el tipo

Entonces, ¿cuál es el tipo del objeto correspondiente de MyArrayList aquí? ¿Es MyArrayList<Integer> o algo así?

Se puede ver aquí que los objetos creados por la instancia son del tipo MyArrayList, y el contenido en <> no participa en la composición de tipos genéricos, entonces ¿dónde está el tipo en <>? Esto es para entender el mecanismo de trabajo de los genéricos.

2. ¿Cómo se compilan los genéricos?

Una diferencia importante entre las matrices y los genéricos es cómo imponen la verificación de tipos. Específicamente, las matrices almacenan y verifican la información de tipo en tiempo de ejecución . Sin embargo, los genéricos se comprueban en busca de errores de tipo en tiempo de compilación y no tienen información de tipo en tiempo de ejecución .

Mecanismo de compilación genérico: mecanismo de borrado

En tiempo de compilación, E en MyArrayList se borra para ser de tipo Object.

En el método principal, se borran en el tipo MyArrayList.

Referencia: crear una matriz genérica en Java