La façon la plus simple de comprendre les génériques Java est de le considérer comme une syntaxe pratique qui peut vous faire économiser des opérations sur le casting de type Java:
List <Poule> box = ...; Apple Apple = Box.get (0);
Le code ci-dessus lui-même a clairement exprimé: Box est une liste avec des objets Apple. La méthode GET renvoie une instance d'objet Apple, et ce processus ne nécessite pas de conversion de type. Il n'y a pas de génériques, le code ci-dessus doit être écrit comme ceci:
Liste Box = ...; Apple Apple = (Apple) Box.get (0);
Il est évident que le principal avantage des génériques est de permettre au compilateur de conserver les informations de type des paramètres, d'effectuer des vérifications de type et d'effectuer des opérations de conversion de type: le compilateur garantit que ces conversions de type sont absolument correctes. Par rapport à s'appuyer sur les programmeurs pour se souvenir des types d'objets et effectuer des conversions de type - cela entraînera des échecs lorsque le programme est exécuté, ce qui est difficile à déboguer et à résoudre. Le compilateur peut aider les programmeurs à forcer un grand nombre de contrôles de type au moment de la compilation et à trouver des erreurs.
La composition des génériques
La composition des génériques conduit au concept de variables de type. Selon la spécification de la langue Java, les variables de type sont un type de glyphe sans restriction, qui découlent des situations suivantes:
Déclaration de classe générique Déclaration d'interface générique Déclaration de méthode générique Déclaration de constructeur générique
Classes et interfaces génériques
S'il y a une ou plusieurs variables de type sur une classe ou une interface, c'est un générique. Les variables de type sont définies par des supports d'angle et placées après le nom de classe ou d'interface:
Liste d'interface publique <T> étend la collection <T> {...}Autrement dit, le rôle des variables de type est comme un paramètre, qui fournit des informations au compilateur pour la vérification de type.
De nombreuses classes de la bibliothèque de classes Java, comme l'ensemble du cadre de collection, ont été modifiées sous forme générique. Par exemple, l'interface de liste que nous avons utilisée dans le premier code ci-dessus est une classe générique. Dans ce code, Box est un objet List <ple>, qui est une instance d'une implémentation de classe d'une interface de liste avec une variable de type Apple. Le compilateur utilise ce paramètre de variable de type pour convertir automatiquement la méthode GET lorsqu'elle est appelée et renvoie un objet Apple.
En fait, cette nouvelle balise générique émergente, ou la méthode GET dans cette interface de liste, est la suivante:
T get (int index);
La méthode GET renvoie en fait un objet de type T, qui est une variable de type dans la déclaration de liste <T>.
Méthodes et constructeurs génériques
Très similaire, si une ou plusieurs variables de type sont déclarées sur la méthode et le constructeur, ils peuvent également être génériques.
public statique <t> t GetFirst (liste <T> Liste)
Cette méthode acceptera un paramètre List <T> et renverra un objet de type T. Vous pouvez utiliser les classes génériques fournies dans la bibliothèque de classes Java, ou vous pouvez utiliser vos propres classes génériques. Données d'écriture de type type ... Le code suivant est un exemple. Nous créons une instance de liste <string> puis chargeons quelques données:
List <string> str = new ArrayList <string> (); str.add ("bonjour"); str.add ("monde.");Si nous essayons de charger un autre objet dans List <string>, le compilateur invitera une erreur:
str.add (1);
Données de lecture de type type ...
Lorsque nous utilisons un objet List <string>, il garantit toujours que nous obtenons un objet String:
String myString = str.get (0);
Traversion: de nombreuses classes de la bibliothèque de classe, telles que Iterator <T>, ont des fonctions améliorées et sont génériques. La méthode Iterator () dans l'interface List <T> renvoie désormais Iterator <T>. L'objet renvoyé par sa méthode t suivant () n'a pas besoin d'être converti de type, vous obtenez directement le type correct.
for (iterator <string> iter = str.iterator (); iter.hasnext ();) {string s = iter.next (); system.out.print (s);}Avec Foreach, la syntaxe "pour chaque" bénéficie également des génériques. Le code précédent peut être écrit comme ceci:
pour (String s: str) {System.out.print (s);}C'est facile à lire et à entretenir.
Encapsulation automatique (autoboxing) et déballage automatique (Autounboxing). Lorsque vous utilisez Java Generics, les deux fonctionnalités de Autoboxing / Autounboxing seront automatiquement utilisées, tout comme le code suivant:
List <Integer> ints = new ArrayList <Neger> (); int.add (0); int.add (1); int sum = 0; pour (int i: intS) {sum + = i; }Cependant, une chose que vous devez comprendre est que l'emballage et le déballage entraîneront des pertes de performances, et tout cela devrait être utilisé avec prudence.
Les génériques sont une nouvelle fonctionnalité de Java SE 1.5. L'essence des génériques est un type paramétré, c'est-à-dire que le type de données opéré est spécifié comme un paramètre. Ce type de paramètre peut être utilisé dans la création de classes, d'interfaces et de méthodes, et est appelé classe générique, interfaces génériques et méthodes génériques respectivement.
L'avantage de l'introduction de génériques en langue java est qu'ils sont sûrs et simples.
Avant Java SE 1.5, sans génériques, «l'arbitraralisation» des paramètres a été réalisée en faisant référence à l'objet type. L'inconvénient de «l'arbitraralisation» était qu'une conversion explicite de type coulé était nécessaire, et cette conversion a obligé les développeurs à prédire le type de paramètre réel. En cas d'erreurs de conversion de type coulé, le compilateur peut ne pas provoquer une erreur et une exception ne se produira que lors de l'exécution, ce qui représente un risque de sécurité.
L'avantage des génériques est qu'ils vérifient la sécurité du type lors de la compilation, et tous les moulages sont automatiques et implicites, améliorant le taux de réutilisation du code.
Il existe certaines règles et restrictions dans l'utilisation des génériques:
1. Les paramètres de type des types génériques ne peuvent être que des types de classes (y compris des classes personnalisées), pas des types simples.
2. Le même type générique peut correspondre à plusieurs versions (car le type de paramètre est incertain) et les instances de classe générique de différentes versions sont incompatibles.
3. Il peut y avoir des paramètres de type multiple pour les génériques.
4. Les types de paramètres génériques peuvent utiliser des instructions étend, par exemple. Devenir habituellement un "type limité".
5. Le type de paramètre d'un type générique peut également être un type de tableau générique. Par exemple, classe classtype = class.forname (java.lang.string);
Les génériques ont également des interfaces, des méthodes, etc., avec beaucoup de contenu, et il faut un certain effort pour les comprendre, les maîtriser et les appliquer avec compétence. Voici deux exemples que j'ai écrits lorsque j'ai appris sur les génériques (écrits sur la base de l'impression que j'ai vue), qui peut réaliser la même fonction. L'un utilise des génériques et l'autre non. Grâce à la comparaison, vous pouvez rapidement apprendre l'application des génériques. Apprenez cela et apprenez essentiellement 70% du contenu des génériques.
Exemple 1: les génériques sont utilisés
classe publique gent {privé T ob; // définir la variable de membre générique Gen public (t ob) {this.ob = ob; } public t getOB () {return ob; } public void setOB (t ob) {this.ob = ob; } public void showtyep () {System.out.println ("Le type réel de T est:" + ob.getClass (). getName ()); }} classe publique Gendemo {public static void main (String [] args) {// définir une version entière de la classe générique gen gén = new GenInteger (88); intob.showtyep (); int i = intoB.getOB (); System.out.println ("value =" + i); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Exemple 2: aucun générique n'est utilisé
classe publique Gen2 {objet privé ob; // Définir un membre de type général public Gen2 (objet ob) {this.ob = ob; } objet public getOB () {return ob; } public void setOB (objet ob) {this.ob = ob; } public void showtyep () {System.out.println ("Le type réel de T est:" + ob.getClass (). getName ()); }} classe publique Gendemo2 {public static void main (String [] args) {// définir une version entière de la classe Gen2 Gen2 intoB = new Gen2 (new Integer (88)); intoB.showtyep (); int i = (INTER) intoB.getOB (); System.out.println ("value =" + i);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ strob.getOB (); System.out.println ("Value =" + S);Résultats en cours:
Les résultats de l'exécution de la démo dans les deux exemples sont les mêmes, et la sortie de la console est la suivante:
Le type réel de T est:
java.lang.integer
valeur = 88
----------------------------------
Le type réel de T est: java.lang.string
Value = Hello Gen!
Processus terminé avec le code de sortie 0
Si vous comprenez cela, vous ne serez pas un problème à l'avenir lorsque les applications génériques de base et la lecture de code.
Ce qui précède est un exemple d'analyse des génériques Java. Les amis qui apprennent les génériques Java peuvent y faire référence.