Théorie 3.2: structure générique (2) #

• Comment restreindre une liste générique à un type précis?

  • liste de chaînes, liste d’entiers, liste de Vehicule

• Comment prévenir une erreur d’exécution de ce genre:

MaListe listeChaines = new MaListe(new String[] {"25","45","4","5"});

// Permis?
listeChaines.modifierValeur(0, 12);
listeChaines.modifierValeur(0, new Auto(12.9));

// Oups, erreur d'exécution
String chaine = (String) tableauChaines.valeurMinimale();

• La technique à utiliser s’appelle les paramètres de type

Utiliser les paramètres de type #

• Un paramètre de type permet de spécifier quel genre de Liste on veut:

MaListe<Integer> listeEntiers = new MonTableau<>(new Integer[] {54,1,5,43,6});

MaListe<String> listeChaines = new MonTableau<>(new String[] {"25","45","4","5"});

MaListe<Vehicule> listeVehicules = new MonTableau<>(new Vehicule[] {new Auto(13.0), new Moto(23.9), new Camion(134.0)});

• <Integer> est le paramètre de type restreignant la liste aux entiers

• <String> est le paramètre de type restreignant la liste aux chaînes

• <Vehicule> est le paramètre de type restreignant la liste aux Vehicule

• Le paramètre vide <> est rempli (deviné) par le compilateur, lorsque possible

  • p.ex. la première ligne équivaut à:

MaListe<Integer> listeEntiers = new MonTableau<Integer>(new Integer[] {54,1,5,43,6});
//                                             ^^^^^^^

Erreurs de compilation #

• Grace aux paramètres de type, le compilateur peut faire plus de vérifications

• Certaines erreur d’exécution deviennent des erreurs de compilation:

// Erreurs de compilation!!
listeEntiers.modifierValeur(0, "12");
listeChaines.modifierValeur(0, new Auto(12.3));
listeVehicules.modifierValeur(0, 123);

L’interface Liste avec paramètres de type #

public interface Liste<C extends Comparable> {

    C obtenirValeur(int index);

    void modifierValeur(int index, C nouvelleValeur);

    C valeurMinimale();
}

• Le paramètre <C extends Comparable> se lit:

  • le type C est une sous-classe de Comparable

• Le type C est ensuite utilisé où Comparable serait utilisé

Implanter Liste avec paramètres de type #

• L’implantation commence comme suit:

public class MaListe <C extends Comparable> implements Tableau<C> {
    
    private C[] valeurs;
    
    public MaListe(C[] valeurs) {
        this.valeurs = valeurs;
    }
}

• Il y a deux paramètres de type:

  • <C extends Comparable> indique: le type C est une sous-classe de Comparable
  • <C> spécifie que l’interface Liste est utilisée avec le type C

• L’implantation des méthodes utilise le type C:

@Override
public C obtenirValeur(int index) {
    return valeurs[index];
}

@Override
public void modifierValeur(int index, C nouvelleValeur) {
    valeurs[index] = nouvelleValeur;
}

@Override
public C valeurMinimale() {
    C valeurMinimale = null;
    
    if(valeurs.length > 0) {
        valeurMinimale = valeurs[0];
    }
    
    for(int i = 1; i < valeurs.length; i++) {
        if(valeurs[i].compareTo(valeurMinimale) < 0) {
            valeurMinimale = valeurs[i];
        }
    }
    
    return valeurMinimale;
}

Il reste une erreur d’exécution! #

• Le code ci-bas va compiler, mais provoquer une erreur d’exécution:

MaListe<Vehicule> listeVehicules = new MaListe<>(new Vehicule[] {new Auto(13.0), new Moto(23.9), new Camion(134.0)});

// Permis??
listeVehicules.valeurMinimale().compareTo(12);

• Pour régler l’erreur il faut spécifier cette notion:

  • un Vehicule peut seulement être comparé à un autre Vehicule

• Pour ce faire, il faut paramétrer Comparable quand on définit Vehicule

public abstract class Vehicule implements Comparable<Vehicule> {

	@Override
	public int compareTo(Vehicule autre){
	    int resultat = 0;

	    if(this.totalKilometres < autre.totalKilometres){
	        resultat = -1;
	    }else if(this.totalKilometres > autre.totalKilometres){
	        resultat = +1;
	    }

	    return resultat;
	}
}

• De la même façon, il faut paramétrer Comparable quand on définit Liste

public interface Liste<C extends Comparable<C>> {

    C obtenirValeur(int index);

    void modifierValeur(int index, C nouvelleValeur);

    C valeurMinimale();
}

• Le paramètre de type <C extends Comparable<C>> se lit:

  • C est un sous-type de Comparable qui peut seulement se comparer à C

• Les avertissements de type incomplet devraient ainsi disparaîtrent