Java Generics (définit les classes et les méthodes)

À propos de la syntaxe de définition des classes et méthodes génériques en Java. Voir ici pour les termes → Points of Java Generics

Paramètre temporaire

Par exemple, si `List <E>`, alors E entre crochets angulaires est le paramètre formel. En termes de grammaire, il n'y a pas de problème même s'il y a deux caractères ou plus ou un mélange de lettres minuscules, mais par convention, un caractère est souvent utilisé. <e>Ou<t>ChaqueelementOutypeC'est une abréviation pour.

Contraintes sur les paramètres de pseudotype

Il existe certaines restrictions car les informations de paramètre de type sont effacées au moment de l'exécution. -- nouveau T () `` `` ne peut pas être fait -- new T [] `` `ne peut pas être fait

• `` `T.class``` ne peut pas être référencé
• obj instance de T ne peut pas être évalué

Comment définir une classe générique

Si vous écrivez SomeClass <T> '', vous pouvez utiliser son paramètre de type `` T``` dans les champs de la classe et dans les méthodes (y compris les arguments et les valeurs de retour).

//↓ Écrivez ici le paramètre de type
public class SomeClass<T> {
  private T t;
  private List<T> list = new ArrayList<T>();
  public void set(T arg){
    this.t = arg;
  }
  public T get(){
    return this.t;
  }
}

Notez que les paramètres formels d'une classe générique ne peuvent pas être utilisés dans les méthodes statiques ou les instructions statiques de cette classe comme indiqué ci-dessous.

public class Hoge<T>{
  static {
    T t; //Erreur de compilation
  }
  public static void hoge(T t){ //Erreur de compilation
  }
}

Comment définir une méthode générique

Si vous écrivez <T> '' avant le type de retour de la méthode, le paramètre de type T '' peut être utilisé dans la méthode.

  //↓ Écrivez ici le paramètre de type
  public static <T> ArrayList<T> someMethod(T arg){
    ArrayList<T> list = new ArrayList<T>();
    list.add(arg);
    return list;
  }

C'est tout pour les bases de la définition de classe générique et de la définition de méthode, puis nous changerons le contenu du paramètre formel `` '' en fonction du cas.

Paramètres de type multiples

Vous pouvez utiliser plusieurs paramètres de type séparés par des virgules.

  public static <K, V> HashMap<K, V> newHashMap(){
    return new HashMap<K, V>();
  }

  // ※<K,V>Le type de est deviné du côté gauche
  Map<String, Integer> map = newHashMap();

Paramètres aux limites

<t étend les classes et les interfaces>Si vous écrivez commetPeut exiger que l'appelant soit une sous-classe de la classe spécifiée (ou de la classe spécifiée elle-même).

  //ArrayList qui peut être instancié uniquement avec la sous-classe de type Number ou le type Number
  public class NumArrayList<T extends Number> extends ArrayList<T> {}

  List<Number> numberList = new NumArrayList<Number>(); // ok
  List<Double> doubleList = new NumArrayList<Double>(); // ok
  List<String> stringList = new NumArrayList<String>(); //Erreur de compilation

Limite récursive

Cet exemple requiert de l'appelant que E soit une classe d'implémentation de Comparable .

  //Méthode pour récupérer la valeur maximale de la collection
  public static <E extends Comparable<E>> E max(Collection<E> collection) {
    //Code omis. E est comparer à(E)Parce qu'il a une méthode
    //Vous pouvez l'utiliser pour implémenter un algorithme qui trouve la valeur maximale d'un élément.
  }

Spécifications d'héritage multiples

Pour spécifier qu'il s'agit d'une classe d'implémentation de plusieurs interfaces, connectez la classe parent et les interfaces avec `` & ''.

//Nécessite E pour implémenter les interfaces comparables et sérialisables
public class Fuga<E extends Comparable<E> & Serializable>{}

(`&` ʻEst un symbole très peu familier, mais j'utilise` `&` `parce que`, ```est déjà utilisé comme délimiteur de paramètre de type Je pense que le)