1. Le concept de base des génériques
Comme C #, Java a le concept de génériques et le paramétrage des types. Les génériques en Java apparaissent après JDK5.0, mais les génériques en Java sont essentiellement différents des génériques en C #. Tout d'abord, du point de vue des types de collection, ArrayList <Integer> et ArrayList <string> en java sont le même type. L'effacement de type sera effectué pendant la compilation, et les types de Java sont la pseudogénérique. La pseudogénérique sera introduite plus tard. Deuxièmement, lors de l'ajout de types de données de base à une collection, tels que INT, INT sera d'abord converti en un objet entier, ce que nous appelons généralement l'opération de boxe. Lorsque vous éliminez les éléments, l'objet Interger doit être converti en type de valeur int, c'est-à-dire un fonctionnement de déballage. En C #, la liste <nt> et la liste <string> sont des types différents. Les paramètres génériques seront un espace réservé après compilation et ne seront pas effacés. Ils se voient attribuer de vrais types lors de l'exécution. Ils sont générés pendant l'exécution du système et ont leurs propres tables de méthode virtuelle et types de données. Cette implémentation est appelée inflation de type (pour l'inflation de type, le compilateur instantané a fait beaucoup de travaux d'optimisation pour résoudre ce problème). Ce sont les soi-disant véritables génériques. Dans le même temps, lors de l'ajout d'éléments de base tels que INT à une collection, il n'est pas nécessaire de boxer et aucune déballage n'est requise lors de la suppression des éléments. Par conséquent, les performances sont meilleures que les génériques de la collection Java.
L'introduction des génériques en Java est principalement pour résoudre deux problèmes: 1. Des exceptions de remplacement de type se produisent pendant l'élément d'exécution de l'élément de type de collection, et des vérifications de type sont ajoutées pendant le type de temps de compilation. 2. Répéter l'écriture de code pendant la solution et l'algorithme peut être réutilisé. Ce qui suit est un exemple pour illustrer la vérification de type du compilateur.
Tout d'abord, regardons un exemple où les génériques ne sont pas utilisés:
ArrayList al = new ArrayList (); al.add ("ABC"); al.add ("124"); al.add ("32L");Nous pouvons ajouter tout type de données à la collection AL. Lorsque nous devons convertir le type lors de la récupération des données, comme:
String S = (String) al.get (0); String S1 = (String) al.get (1); // Dans la période d'exécution, une erreur sera signalée et l'erreur de conversion de type sera longue l = (long) al.get (2);
À partir de cela, nous pouvons voir que lorsqu'il n'y a pas de génériques, la vérification des types est réduite pendant la compilation. Lorsque vous éliminez les éléments, les programmeurs doivent connaître les types de chaque élément, sinon une exception de la conversion de type peut se produire au moment de l'exécution.
Jetons donc un coup d'œil aux avantages qu'il nous apporte grâce à des collections génériques.
ArrayList <string> al1 = new ArrayList <string> (); al1.add ("ABC"); al1.add (1); // une erreur s'est produite pendant la compilation,Lorsque nous instancions AL1 avec le type de paramètre de chaîne, nous ne pouvons pas ajouter un élément int, sinon le compilateur rapportera une erreur. Habituellement, il y aura une marque d'erreur dans l'éditeur IDE, comme Eclipse. Dans le même temps, il n'est pas nécessaire de taper la conversion lors de l'extraction de l'élément.
String Value = al1.get (0); // Aucune conversion de type n'est requise
C'est l'avantage des génériques.
Ensuite, le multiplexage des algorithmes se reflète principalement dans le multiplexage des méthodes, telles que la méthode ADD de ArrayList, qui peut être utilisée sur n'importe quel type ou type limité.
2. Utilisation des génériques
Les génériques en Java sont principalement utilisés dans les classes, les méthodes et les interfaces. Tout d'abord, jetons un bref aperçu de l'utilisation de la classe:
Classe Factory <T> {Valeur T privée; public t getValue () {return Value; } public void setValue (t v) {this.value = v; }}Ajouter une méthode de test:
Factory <string> f = new factory <string> (); f.setValue ("Factory in use"); System.out.println (f.getValue ());Utilisation des interfaces génériques:
interface myInterface <t, u> {void show (t t, u u); } classe ShowTest implémente MyInterface <String, Integer> {@Override public void show (String t, Integer u) {System.out.println (t); System.out.println (U); }}Lorsqu'un paramètre de type générique agit sur une classe, il restreint principalement les contraintes de type entre plusieurs champs et signatures de méthode. Lorsque vous agissez sur une méthode, les principales contraintes sont effectuées sur plusieurs paramètres de la méthode. Ici, les paramètres de type générique de la méthode ne recevront plus d'exemples. Préduisons principalement les contraintes des paramètres de type ci-dessous.
3. Type Contraintes de paramètres
Regardons un petit exemple, comme indiqué dans le code suivant:
public statique <t> t get (t t1, t t2) {if (t1.compareto (t2)> = 0); // Erreur de compilation, la méthode compareto (t) n'est pas définie pour le type t. return t1; }Vous pouvez voir le message d'erreur du compilateur. La méthode compareto n'est pas définie pour le type T. Si les types doivent être comparés dans Java, l'interface comparable doit être implémentée, de sorte que la méthode est remplacée. Ensuite, nous apportons les modifications suivantes:
Le public statique <T étend comparable> t get (t t1, t t2) {// ajouter la limitation de type if (t1.compareto (t2)> = 0); retour t1; }En qualifiant T étend comparable, il montre que t est le type d'interface qui implémente comparable, et implémente donc également la méthode de comparaison, il n'y aura donc pas d'erreurs de temps de compilation.
Lorsque nous utilisons et pour segmenter plusieurs limitations des types, nous pouvons utiliser et segmenter les mots clés limités, et seuls les étendus peuvent être utilisés. Dans le même temps, lorsque les interfaces et les types existent, la classe ne peut être placée qu'en premier et ne peut en avoir qu'une, comme indiqué ci-dessous:
<T étend l'objet et comparable et sérialisable>
L'article ci-dessus discute brièvement du rôle et des concepts de base des génériques Java est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.