précédent | suivant | table des matières

Programmation générique

 

La généricité permet de définir des classes, ou des méthodes paramétrées par une ou plusieurs autres classes.

Pourquoi la généricité ?

 Exemple :

 

public class Paire  {

    Object premier ;

    Object second;

    public Paire (Object a, Object b){

        premier a; second = b;

    }

    public object getPremier(){

        return premier;

    }

    public object getSecond(){

        return second;

    }

}

     Paire  p = new Paire  ("abc", "xyz");

     String x =  (String)p.getPremier(); // le casting est obligatoire

     Double y =  (Double)p.getSecond();  // Il faut attendre l'exécution pour avoir 

                                         // une levée d'exception (ClassCastException)

           

public class Paire<T>  {

    T premier ;

    T second;

    public Paire (T a, T b){

        premier a; second = b;

    }

    public T getPremier(){

        return premier;

    }

    public T getSecond(){

        return second;

    }

}

     Paire<String>  p = new Paire<String>  ("abc", "xyz");

     String x =  p.getPremier(); // pas de cast

     Double y =  p.getSecond();  // erreur de compilation (type mismatch)

2Méthode générique

 

On peut définir une méthode générique dans une classe de la façon suivante :

public class X {
   
    public <T> void affiche(Paire<T>p){
        System.out.println(p);
    }
   
    public static void main(String [] a){
        Paire<String> ps = new Paire<String>("un", "deux");
        Paire<Integer> pi = new Paire<Integer>(1, 2);
        X x = new X();
        x.affiche(ps);
        x.affiche(pi);
    }
}

 

3La généricité et l’héritage

Soient les deux classes suivantes :

public class Super {

   ...

}
public class Sous extends Super {
   ...

}
 

Il n'existe pas de relation d'héritage entre Paire<Super> et Paire<Sous>.

Paire<Super> pSup = new Paire<Super>(new Super());

Paire<Sous>  pSous = new Paire<Sous>(new Sous());

 pSup = pSous ; // INTERDIT

4Joker

Supposons que nous définissions dans la classe X une autre méthode pour afficher des paires de Super, de la façon suivante :

public  void afficheS(Paire<Super>p){
        System.out.println(p);
}

  Paire<Super> ps = new Paire<Super>();

  Paire<Sous> pso = new Paire<Sous>();

  

  x.afficheS(ps);

OK, pas de problème.
  x.afficheS(pso); NON, pso n’est pas unePaire de Super

Pour que la dernière instruction soit possible il faudrait définir la méthode afficheS de la façon suivante : 
public  void afficheS(Paire<?> p){
        System.out.println(p);
}

Mais dans ce cas tout est possible, et si on veut se limiter aux classes qui dérivent de Super :
public  void afficheS(Paire<? extends Super> p){
        System.out.println(p);
}


 

Les jokers peuvent être limités vers le haut  (extends) ou vers le bas (super). 

On a les relations d'héritage suivantes :

généricité1.gif
 généricité 2 .gif


La relation d'héritage entre Paire et Paire<?> est là pour assurer la compatinilité avec les codes existants avant la version 5 de JAva.

Généricité en Java et en C++

 

Les template C++ génèrent à la compilation autant de fichiers objets que d’instanciations des templates. Ceci n’est pas vrai en Java ou il n’y a qu’une seule instance de code généré à la compilation.


haut de la page