Genérico
¿Qué es genérico?
La genérica, es decir, 'tipos parametrizados', como su nombre lo indica, es parametrizar el tipo del tipo específico original, similar a los parámetros variables en el método, en este momento el tipo también se define como una forma de parámetro (que se puede llamar parámetro de tipo), Luego, pase el tipo específico (argumento de tipo) al usar / llamar.
¿Por qué usar genéricos?
Primero mira un ejemplo:
List list = new ArrayList();
list.add("abc");
list.add(1);
for (Object o : list) {
String str = (String)o;
System.out.println(str.length());
}
El resultado de ejecutarse en esta pequeña demostración: java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
ahora esos resultados no son lo que queremos, pero ¿cómo evitar tales errores?
Esta vez, es necesario usar genéricos:
List<String> list = new ArrayList<>();
list.add("abc");
//list.add(1); //报错，不能添加非字符串类型
list.add("efg");
Cuando lo declaremos, agregue genéricos, que es un tipo de cadena, por lo que si usa esta colección para agregar valores de otros tipos, él informará un error y aún informará un error en la etapa de compilación.
Por lo tanto, el uso de genéricos puede evitar efectivamente los errores encontrados durante la compilación y puede encontrar y modificar errores rápidamente.
Características genéricas
Aquí hay un ejemplo, adivina la respuesta en casa:
List<String> stringList = new ArrayList<>();
List<Integer> integerList = new ArrayList<>();
System.out.println(stringList.equals(integerList));
Esta sección del código anterior, la definición de los dos conjuntos, entonces el conjunto de datos no se almacenan, pero no son el mismo genérico, y, finalmente, comparar sus resultados: true.
Esta es la característica de los 泛型的擦除genéricos. Los genéricos solo son efectivos en la etapa de compilación. Al compilar, siempre que la compilación sea correcta, la información relevante de los genéricos se borrará, por lo que la información de los genéricos no entrará en la ejecución Etapa.
Por supuesto, a veces, después de definir el tipo genérico, debe almacenar otros tipos. En este momento, puede usar la reflexión para almacenar datos en el contenedor.
Clasificación genérica
Los medicamentos genéricos se dividen en tres 泛型类tipos: 泛型接口, 泛型方法,.
Letras comunes genéricas:
T Type representa el tipo.
K representa la clave en el par clave-valor
V representa el valor en el par clave-valor
E representa el elemento
? Indica un tipo incierto
Clase genérica
Defina una clase genérica:
public class Student<T> {
T id;
public T getId(T id) {
return id;
}
public void setId(T id) {
this.id = id;
}
}
Uso:
Student<Integer> stu = new Student<>();
stu.setId(1);
Integer id = stu.getId();
System.out.println(id); //1
Student<String> stuStr = new Student<>();
stuStr.setId("10001");
String strid = stuStr.getId();
System.out.println(strid); //10001
Student stuStr = new Student);
stuStr.setId("2222");
Object objid = stuStr.getId();
System.out.println(objid); //2222
En el ejemplo anterior, podemos ver que al usar diferentes genéricos para declarar objetos, los tipos de identificación almacenados dentro y fuera son los mismos, y si no se definen genéricos, el valor predeterminado es el tipo de objeto. Es un borrado genérico. Si se define, todas las Studentclases <T>se reemplazarán con el tipo de estudio de declaración.
Herencia de clases genéricas
En la herencia de genéricos, los métodos anulados están determinados por el tipo genérico de la clase principal. Si la clase principal no determina el tipo genérico, entonces la clase secundaria no puede especificar el tipo genérico. Si ni la clase primaria ni la clase secundaria especifican genéricos, a continuación, <T>será el Objectsustituto. Al definir propiedades en una subclase, se basa en los genéricos de la subclase.
La clase padre especifica genéricos
class Test extends Student<String>{
@Override
public String getId() {
return super.getId();
}
@Override
public void setId(String id) {
super.setId(id);
}
}
Las clases para padres e hijos no son genéricas
class Test1 extends Student{
@Override
public Object getId() {
return super.getId();
}
@Override
public void setId(Object id) {
super.setId(id);
}
}
Las clases para padres e hijos tienen genéricos
class Test2<T> extends Student<T> {
@Override
public T getId() {
return super.getId();
}
@Override
public void setId(T id) {
super.setId(id);
}
}
Solo las subclases tienen genéricos
class Test2<T> extends Student {
@Override
public Object getId() {
return super.getId();
}
@Override
public void setId(Object id) {
super.setId(id);
}
}
Interfaz genérica
Cuando se usa la interfaz genérica, la definición de la clase genérica es la misma, sin importar la realidad o la herencia, es la misma que la clase genérica.
public interface GenericInterface<T> {}
Método genérico
Formato de método genérico:
修饰符 <代表泛型的变量> 返回值类型 方法名（参数列表）{}
Los métodos que contienen genéricos determinan el tipo de datos del genérico cuando se llama al método, qué tipo de parámetros se pasan y de qué tipo es el genérico.
Defina un método genérico y use:
public static void main(String[] args) {
Demo01 demo01 = new Demo01();
demo01.test("a"); //a
demo01.test(2); //2
demo01.test(false); //false
demo01.test(0.01); //0.01
Demo01.staticTest(4); ///4
}
/*
普通泛型方法
*/
public <T> void test(T t) {
System.out.println(t);
}
/*
静态泛型方法
*/
public static <T> void staticTest(T t) {
System.out.println(t);
}
¡Los detalles determinan el éxito o el fracaso!
Personalmente, me siento humilde.