Utilisation générique de Java (classes, méthodes, protocoles d'interface, caractères génériques de type, limites supérieure et inférieure des caractères génériques)

1. Introduction

• 泛型: JDK5est une fonctionnalité introduite dans , qui fournit un mécanisme de détection de sécurité de type au moment de la compilation, qui permet de détecter les types illégaux au moment de la compilation. Son essence est un type paramétré, ce qui signifie que le type de données manipulé est spécifié en tant que paramètre .

• En ce qui concerne les paramètres, le plus courant consiste à définir une méthode avec des paramètres formels, puis à transmettre les paramètres réels lors de l'appel de la méthode. Alors, comment comprenez-vous les types paramétrés ? Comme son nom l'indique, il s'agit de paramétrer le type par le type concret d'origine, puis de transmettre le type concret lors de l'utilisation/de l'appel.

• Ce type de paramètre peut être utilisé dans des classes, des méthodes et des interfaces, appelées respectivement classes génériques, méthodes génériques et interfaces génériques.

• 泛型Format de définition :

  • <类型>: Spécifie le format d'un type, où le type peut être considéré comme un paramètre formel.

  • <类型1,类型2...>: spécifiez le format de plusieurs types et séparez-les par des virgules. Les types ici peuvent être considérés comme des paramètres formels.

  • À l'avenir, le type donné dans l'appel spécifique pourra être considéré comme un paramètre réel, et le type du paramètre réel ne pourra être qu'un type de données de référence.

• 泛型les avantages de :

  • Déplacement des problèmes d'exécution vers le temps de compilation

  • Évitez les plâtres

2. Classe générique

• 泛型类Le format de définition de :

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

  • Exemple:public class Generic<T> { }

  • Ici Tpeut être écrit comme n'importe quel identifiant, et des T、E、K、 Vparamètres communs tels que et sont souvent utilisés pour représenter des génériques.

• Définir une classe générique publiqueGeneric.java

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

• mainLorsqu'il est utilisé dans une fonction, spécifiez le type générique comme String, lors de l'utilisation d'une classe générique, tous les types génériques pointent vers this String.

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

  

3. Méthode générique

• 泛型方法Le format de définition de :

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

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

• Cas:

  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);
    }
  }
  复制代码

  production:

  dzm
  88
  true
  复制代码

4. Protocole d'interface générique

• 泛型接口协议Le format de définition de :

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

  • Exemple:public interface Generic<T>{ }

• définir un protocole d' Generic.javainterface

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

• Définir une GenericPro.javaclasse pour se conformer au Generic.javaprotocole d'interface

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

Cinq, saisissez un caractère générique

• Afin de représenter Listla , vous pouvez utiliser类型通配符

• 类型通配符Le format de définition de :

  • Tapez le caractère générique :<?>

  • List<?>: indique que le type d'élément est inconnu Listet que ses éléments peuvent correspondre 任何的类型.

  • Ce caractère générique indique Listuniquement qu'il s'agit Listde la classe parente de divers génériques et ne peut pas y ajouter d'éléments.

• 通配符的 上下限：

  • 如果说我们不希望 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或者其父类型
    }
  }
  复制代码