Uso genérico de Java (clases, métodos, protocolos de interfaz, comodines de tipo, límites superiores e inferiores de comodines)

1. Introducción

• 泛型: JDK5es una función introducida en , que proporciona un mecanismo de detección de seguridad de tipo en tiempo de compilación, que permite detectar tipos ilegales en tiempo de compilación. Su esencia es un tipo parametrizado, lo que significa que el tipo de datos que se manipula se especifica como un parámetro.

• Cuando se trata de parámetros, lo más familiar es definir un método con parámetros formales y luego pasar los parámetros reales al llamar al método. Entonces, ¿cómo entiendes los tipos parametrizados? Como su nombre lo indica, es para parametrizar el tipo por el tipo concreto original y luego pasar el tipo concreto al usar/llamar.

• Este tipo de parámetro se puede utilizar en clases, métodos e interfaces, que se denominan clases genéricas, métodos genéricos e interfaces genéricas, respectivamente.

• 泛型Formato de definición:

  • <类型>: especifica el formato de un tipo, donde el tipo se puede considerar como un parámetro formal.

  • <类型1,类型2...>: especifique el formato de varios tipos y sepárelos con comas. Los tipos aquí se pueden considerar como parámetros formales.

  • En el futuro, el tipo proporcionado en la llamada específica se puede considerar como un parámetro real y el tipo del parámetro real solo puede ser un tipo de datos de referencia.

• 泛型los beneficios de:

  • Problemas de tiempo de ejecución movidos a tiempo de compilación

  • Evitar yesos

2. Clase genérica

• 泛型类El formato de definición de:

  • Formato:修饰符 class 类名<类型> { }

  • ejemplo:public class Generic<T> { }

  • Aquí Tse puede escribir como cualquier identificador, y los T、E、K、 Vparámetros comunes como y se usan a menudo para representar genéricos.

• Definir una clase genérica públicaGeneric.java

  public class Generic<T> {
    // 定义私有属性
    private T t;
    // 重写 get 方法
    public T getT() {
      return t;
    }
    // 重写 set 方法
    public void setT(T t) {
      this.t = t;
    }
  }
  复制代码

• mainCuando se usa en una función, especifique el tipo genérico como String, cuando se usa una clase genérica, todos los tipos genéricos apuntan a este String.

  public class test {
    public static void main(String[] args) {
      // 新建对象
      Generic<String> g1 = new Generic<String>();
      // 使用 set 方法
      g1.setT("dzm");
    }
  }
  复制代码

  

3. Método genérico

• 泛型方法El formato de definición de:

  • Formato:修饰符 <类型> 返回值类型 方法名(类型量名){ }

  • ejemplo:public <T> void show(T t){ }

• Caso:

  public class test {
    public static void main(String[] args) {
      // 使用泛型方法
      DZMLog("dzm");
      DZMLog(88);
      DZMLog(true);
    }
  
    // 泛型方法
    static <T> void DZMLog(T t) {
      System.out.println(t);
    }
  }
  复制代码

  producción:

  dzm
  88
  true
  复制代码

4. Protocolo de interfaz genérico

• 泛型接口协议El formato de definición de:

  • Formato:修饰符 interface 接口名<类型>{ }

  • ejemplo:public interface Generic<T>{ }

• definir un protocolo de Generic.javainterfaz

  public interface Generic<T> {
    // 接口方法定义
    public default void show(T t) {
      System.out.println(t);
    }
  }
  复制代码

• Defina una GenericPro.javaclase para ajustarse al Generic.javaprotocolo de interfaz

  public class GenericPro<T> implements Generic<T> {
    // 继承协议并实现协议方法
    @Override
    public void show(T t) {
      // 实现协议方法
    }
  }
  复制代码

Cinco, escriba comodín

• Para representar Listla , puede usar类型通配符

• 类型通配符El formato de definición de:

  • Escriba comodín:<?>

  • List<?>: indica que el tipo de elemento es desconocido Listy sus elementos pueden coincidir 任何的类型.

  • Este comodín Listsolo indica que es Listla clase principal de varios genéricos y no puede agregarle elementos.

• 通配符的 上下限：

  • 如果说我们不希望 List<?> 是任何泛型 List 的父类，只希望它代表某一类泛型 List 的父类，可以使用类型通配符的上限。

  • 类型通配符 - 上限： <? extends 类型>

  • 范例 List<? extends Number>：它表示的类型是 Number或者其子类型，一定不能是父类型。

  • 类型通配符 - 下限：<? super 类型>

  • 范例 List<? super Number>：它表示的类型是 Number或者其父类型，一定不能是子类型。

• 案例：

  import java.util.List;
  import java.util.ArrayList;
  
  public class test {
    public static void main(String[] args) {
      // 类型通配符: <?>
      List<?> list1 = new ArrayList<String>();
      List<?> list2 = new ArrayList<Number>();
      List<?> list3 = new ArrayList<Integer>();
  
      // 类型通配符 上线: <? extends 类型>
      List<? extends Number> list5 = new ArrayList<String>(); // 这个会报错，因为 String 不属于 Number或者其子类型
      List<? extends Number> list6 = new ArrayList<Number>();
      List<? extends Number> list7 = new ArrayList<Integer>();
  
      // 类型通配符 下线: <? super 类型>
      List<? super Number> list5 = new ArrayList<String>(); // 这个会报错，因为 String 不属于 Number或者其父类型
      List<? super Number> list6 = new ArrayList<Number>();
      List<? super Number> list7 = new ArrayList<Integer>(); // 这个会报错，因为 Integer 不属于 Number或者其父类型
    }
  }
  复制代码