Les génériques Java offrent une sécurité de type compilé et éliminent la coulée en permettant aux paramètres de type dans les classes, les interfaces et les méthodes, tandis que les caractères génériques améliorent la flexibilité lorsque vous travaillez avec des types inconnus; 1. Les génériques permettent un code réutilisable, comme la liste ou la bo?te générique ; 2. Les caractères génériques gèrent les types inconnus: > Pour tout type, ? étend t> pour les sous-types (utiles pour la lecture) et super t> pour les supertypes (utile pour l'écriture); 3. La règle PECS guide l'utilisation: l'utilisation s'étend lorsque le type produit des données (producteur), super quand il consomme des données (consommateur), comme on le voit dans Collection.copy (dest Super T>, Src étend T>); 4. évitez les types bruts, n'utilisez pas les caractères génériques dans les types de retour inutilement, les paramètres de type limitées à effet de levier comme >, et rappelez-vous les limites d'effacement de type utilisation de l'exécution - une utilisation appropriée des génériques et des caractères génériques améliore la sécurité, la clarté et la réutilisabilité du code.

Les génériques Java et les caractères génériques sont des fonctionnalités puissantes qui permettent la programmation de type type, la réduction des erreurs d'exécution et l'amélioration de la lisibilité du code. Introduits dans Java 5, les génériques vous permettent de définir des classes, des interfaces et des méthodes avec des paramètres de type, afin que le même code puisse fonctionner avec différents types tout en attrapant des décalages de type au moment de la compilation. Les caractères génériques étendent cette flexibilité en vous permettant de travailler avec des types inconnus ou limités.

Voici comment les comprendre et les utiliser efficacement.

1. Que sont les génériques?

Les génériques vous permettent de vous résumer sur les types. Par exemple, au lieu d'utiliser des types bruts comme List , vous pouvez utiliser List<string></string> pour vous assurer que seules les cha?nes sont ajoutées.

 List <string> names = new ArrayList <> ();
names.add ("Alice");
// noms.add (123); // Erreur de compilation - Tapez la sécurité!

Sans génériques, vous devrez lancer des objets et risquer ClassCastException à l'exécution.

Avantages clés:

• Vérification du type de compilation
• élimination de la coulée explicite
• Réutilisation de code sur différents types

Vous pouvez également définir vos propres classes et méthodes génériques:

 Classe publique Box <T> {
    valeur t privée;

    public void set (t valeur) {this.value = value; }
    public t get () {return value; }
}

Maintenant, Box<String> , Box<Integer> , etc., sont tous en sécurité.

2. Wildcards: Gestion des types inconnus

Parfois, vous devez travailler avec des types génériques lorsque le paramètre de type exact n'est pas connu. C'est là que les wildcards ( ? ) Entrent en jeu.

La joker illimité ( <?> )

Utilisez lorsque vous ne vous souciez pas du type, généralement pour la lecture des collections.

 public void imprimer (list <?> liste) {
    System.out.println ("Size:" list.size ());
}

Vous ne pouvez pas ajouter d'éléments (sauf null ) car le type réel est inconnu.

La joker à liaison supérieure ( <? extends T> )

Utilisez lorsque vous souhaitez accepter un type et ses sous-types. Commun dans les opérations en lecture seule.

 Public Double Sum (Liste <? Extend Numbers> Numbers) {
    return nombres.Stream (). Maptodouble (nombre :: doubleValue) .sum ();
}

Vous pouvez maintenant passer List<Integer> , List<Double> , etc.

Mais encore une fois, vous ne pouvez rien ajouter (sauf null ) - parce que le compilateur ne conna?t pas le type exact.

La joker à limite inférieure ( <? super T> )

Utilisez lorsque vous souhaitez accepter un type et ses supertypes. Utile pour les opérations d'écriture.

 public void addnumbers (list <? Super Integer> liste) {
    list.add (1);
    list.add (2);
}

Cela fonctionne avec List<Integer> , List<Number> ou List<Object> .

Mais vous ne pouvez pas lire en toute sécurité comme Integer - les éléments peuvent être seulement Object .

3. La règle PECS: le producteur extends , le consommateur super

Un mnémonique utile du livre Java efficace :

PECS : Producteur - extends , consommateur - super

• Si un objet paramétré produit t (vous en lisez T), utilisez <? extends T> .
• S'il consomme t (vous écrivez t), utilisez <? super T> .

Par exemple, dans Collections.copy() :

 Copie publique statique <t> void (liste <? Super T> dest, liste <? étend t> src)

• src est producteur → ? extends T
• dest est un consommateur → ? super T

Appliquez des PEC pour concevoir des API flexibles et s?res.

4. Pièges et astuces communes

• N'utilisez pas les caractères génériques dans les types de retour sauf si nécessaire - il oblige les appelants à faire face à des types inconnus.

• Les types bruts sont dangereux - éviter List au lieu de List<String> .

• Les méthodes génériques peuvent déduire les types:

   public <T> void Print (T item) {...}

• Le type d'effacement signifie que les génériques sont appliqués au temps de compilation uniquement. Aucune information d'exécution (par exemple, vous ne pouvez pas faire new T[]() ).

• Les paramètres de type bordés peuvent contraindre les génériques:

   public <t étend comparable <T>> T max (t a, t b) {
      retour a.compareto (b)> 0? R: B;
  }

  ---

  L'utilisation de génériques et de jokers conduit correctement à un code plus propre et plus s?r. Comprenez quand utiliser extends , les types super ou spécifiques - et rappelez-vous les PEC. Il ne s'agit pas seulement d'éviter les moulages; Il s'agit d'exprimer une intention et de prendre des bugs t?t.

  Fondamentalement, les génériques vous offrent une sécurité en temps de compilation, et les caractères génériques vous offrent la flexibilité de réutiliser le code à travers les hiérarchies de type - sans sacrifier cette sécurité.

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!