Programmation Java/Types génériques

Un livre de Wikibooks.

Programmation

Java

Sommaire

Introduction La notion de machine virtuelle Bases du langage Premier programme Types de base Opérateurs Commentaires Conditions Itérations Tableaux Collections Objets comparables et clés Énumérations Les classes en Java Modificateur d'accès Membres Instanciation et cycle de vie "this" Encapsulation Interfaces Héritage Polymorphisme Classes abstraites Classes internes Transtypage Types génériques Extensions/Packages Exceptions Méta-données Threads et synchronisation Classes de base Sujets connexes Conclusion

IHM avec SWING

Un premier exemple Calculer la somme de 2 entiers Calculer la distance entre 2 points

Annexes

Liste des mots réservés

Modifier ce modèle

Les génériques (de l'anglais generics) sont des classes qui sont typés au moment de la compilation. Autrement dit, ce sont des classes qui utilisent des typages en paramètres. Ainsi une liste chainée, qui peut contenir des entiers, des chaines ou autres pourra être typée en liste de chaine ou liste d'entier et ceci permettra au programmeur de ne pas écrire systématiquement des transtypages, methode qui pourrait s'avérée dangereuse, ce sera le compilateur qui vérifiera la cohérence des données.

Java 5 a introduit un principe de type générique, rappelant les templates (modèles) du C++, mais ceci ne fonctionnant pas tout a fait ceux du C++. En Java le code produit est unique pour tous les objets obtenus à partir de la même classe générique.

Avant java 5

public class MaListe
{
    private LinkedList liste;
    public setMembre(String s) {
       liste.add(s);
    }
    public int getMembre(int i) {
       return (Int)liste.get(i);  }
}

Le transtypage est obligatoire, LinkedList manipule des objets Object, ici le compilateur ne peut détecter de problème, problème qui ne surviendra qu'à l'exécution (RunTimeError).

Dans la version avec génériques, on n'a plus besoin d'utiliser le transtypage donc le compilateur déclenchera deux erreurs durant la compilation, une sur la méthode, l'autre sur l'ajout d'un entier, .

public class Famille
{
    private linkedList < MaClasse > liste;
 
    public setMembre(MaClasse m)
    {
        liste.add(m);
    }
 
    public MaClasse getMembre(int i)
    {
        return liste.get(i);  }
    }
 
    public Int getInt(int i)     //première erreur
    {
        return liste.get(i);  }
    }
}

utilisation :

   Famille<String> famille = new Famille<String>();
   famille.add("essai");
   famille.add(210);          //seconde erreur

Il est important de comprendre que dans la déclaration de la classe le paramètre placé entre les caractères < et > représente bien une classe qui ne sera déterminée que lors de la déclaration de la création de l'objet. Aussi une erreur de typage sera produite à la compilation si les types utilisés par les méthodes ne sont le ou les types attendus. Dans cet exemple, l'erreur sera signalée sur le second ajout.

Dans la déclaration de la classe, la liste membre est déclarée ne pouvant contenir que des objets de classe MaClasse. L'identifiant MaClasse n'est pas une classe existante dans le packages et il est préférable qu'il ne le soit pas pour qu'aucune confusion ne soit faite, c'est à la déclaration de l'objet Famille que l'identifiant MaClasse sera résolu.

Il est évidemment possible d'utiliser un objet d'une classe héritant de celle utilisée pour paramétrer le type générique. Ceci permet de plus d'assurer la compatibilité ascendante avec les versions antérieures de Java : si aucune classe de paramétrage n'est indiquée, la classe par défaut est java.lang.Object.

[modifier] Plusieurs paramètres

De la même façon que pour les classes basées sur les List, les déclarations de vos classes peuvent utilisées ces génériques. Cela permet de rendre le code plus souple et surtout réutilisable dans des contextes très différents. Plusieurs paramètres, séparés par des virgules, peuvent êtres utilisés entre les caractères < et >.

public class ListeDeTruc<Truc, Bidule>
{
    private LinkedList < Truc > liste;
    private ArrayList <Bidule> tableau;
 
    public accumule(Truc m)
    {
        liste.add(m);
    }
 
    public Bidule recherche(int i)
    {
        return tableau.get(i);  }
    }
}

Déclaration possible :

 ListeDeTruc<String,Integer> liste1 = new ListeDeTruc<String,Integer>();
 ListeDeTruc<Thread,Date> liste2 = new ListeDeTruc<Thread,Date>();

[modifier] Génériques et héritages

Lorsqu'un type de base doit répondre à des spécifications précises, il est possible d'écrire des choses du genre :

    public class ListeDeTruc<Truc extends Bidule, MaList<String>> implements Moninterface<Chose>

En revanche, créer une classe qui hérite de ces objets est plus délicat. Ici Chose et Bidule sont des classes existantes, Truc ne sera résolu qu'au moment de la déclaration de l'objet ListeDeTruc.

L'utilisation du mot clef super est possible dans une classe héritant d'une classe générique.

[modifier] Futures versions

Une extension des propriétés des génériques est prévue pour la version 7 de java.