Une introduction:
Avant Javase 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.
2. Paramètres génériques:
Class Gen <T> {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 showType () {System.out.println ("Le type réel de T est:" + ob.getclass (). class genericParameter {public static void main (string [] args) {// définir une version entière de la classe générique gen gen <nteger> intoB = new gen <nteger> (100); intoB.showtype (); int i = intob.getob (); system.out.println ("value =" + i); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- sortir:
Le type réel de T est: java.lang.integer
valeur = 100
--------------------------------------------------------------------------------------------------------------------------------
Le type réel de T est: java.lang.string
Valeur = Bonjour Dylan!
3. Génériques:
classe génériquefoo <T> {private t x; public genericsfoo (t x) {this.x = x;} public t getx () {return x;} public void setx (t x) {this.x = x;}} public class GenericClass {public static vide Main (string args []) {générique Génériques! "); Genericsfoo <pouble> doufoo = new GenericsFoo <Wouble> (nouveau double (" 33 ")); générique <objet> objfoo = new GenericsFoo <objet> (nouveau Object ()); System.out.println ("strfoo.getx =" + strfoo.getx ()); System.out.println ("doufoo.getx =" + doufoo.getx ()); System.out.println ("objfoo.getx =" + objfoo.getx ());}} sortir:
strfoo.getx = Bonjour les génériques!
doufoo.getx = 33.0
objfoo.getx=java.lang.object@1d0fafc
Génériques à quatre limites:
Importer java.util.arraylist; Importer Java.util.collection; classe CollectionGenfoo <T étend Collection> {private t x; public CollectionGenfoo (t x) {this.x = x;} public t getx () {return x;} public Void setx (t x) {this.x = x;}} public class GenericRect # {CollectionGenfoo <RaryList> listfoo = null; listfoo = new CollectionGenfoo <RaryList> (new ArrayList ()); CollectionGenfoo <? étend Collection> listFoo1 = null; listFoo1 = new CollectionGenfoo <RaryList> (new ArrayList ()); System.out.println ("Instanciation réussi!");}}}} sortir:
L'instanciation a réussi!
Cinq méthodes génériques:
classe publique GenericFunction {public <T> void f (t x) {System.out.println (x.getClass (). getName ());} public static void Main (String [] args) {genericfunction ea = new GenericFunction (); ea.f (""); ea.f (10); ea.f ('a'); ea.f (ea); sortir:
java.lang.string
java.lang.integer
java.lang.character
Générique
--------------------------------------------------------------------------------------------------------------------------------
Dylan présente.
Résumer
Ce qui précède est tout le contenu de cet article sur l'explication détaillée des exemples génériques en Java, j'espère que cela sera utile à tout le monde. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!