ntro.ca

        • Contrats de classe
        • Liens utiles
        • Calendrier
        • Calendrier groupe 2
        • Calendrier groupes 1, 3
        • Structure du cours
        • Évaluations
        • Matériel à se procurer
        • Les profs
          • Marc-Olivier Tremblay
          • Mathieu Bergeron
        • Module 1.1: installation + trier des cartes
        • Module 1.2: rappels POO
        • Module 1.3: tableau d'objets
        • Examen 1
        • Module 2.1: données JSON
        • Module 2.2: données en Java
        • Module 2.3: récursivité
        • Examen 2
        • Module 3.1: structure générique
        • Module 3.2: efficacité (1)
        • Module 3.3: efficacité (2)
        • Examen 3
        • Module 4.1: liste naïve
        • Module 4.2: liste par tableau
        • Module 4.3: liste chaînée
        • Examen 4
        • Module 5.1: mappage naïf
        • Module 5.2: mappage par hachage
        • Module 5.3: mappage par arbre
        • Examen 5
        • Équipes
          • Horaire groupe 1
          • Horaire groupe 2
          • Horaire groupe 3
          • Groupe 1
          • Groupe 2
          • Groupe 3
        • Projets vedettes 2022
        • Projets vedettes 2023
        • Projets vedettes 2024
        • Projets vedettes 2025
        • Survol
        • Structure
        • Calendrier
        • Calendrier des séances
        • Évaluations
        • Exemples de jeu
        • Exemples de pages
        • Réponses à vos questions
        • Module 1: créer le projet
        • Module 2: concevoir l'application
        • Module 3: vues NtroFx
        • Module 4: modèle et navigation
        • Module 5: ajouter le dorsal, modifier le modèle
        • Module 7: améliorer l'affichage
        • Module 8: jeu en 2d
        • Module 9: client/serveur
        • Module 10: plusieurs instances du même modèle
        • TP1
        • Examen 1
        • TP2
        • Examen 2
        • Projet de fin de session
        • Calendrier
        • Structure du cours
        • Évaluations
        • Contrat de classe
        • Le prof
        • 01: Windows et Word
          • Astuces et raccourcis
        • 02: Word
        • 03: Word
          • Exercice Word: insertion d'éléments spéciaux
          • Exercice Word: tableaux
        • 04: Word
          • Exercice Word: références
          • TP01: Word (15%)
        • 05: PowerPoint
          • TP02: PowerPoint (10%)
        • 06: Examen Word (20%)
        • 07: Excel
        • 08: Excel
        • 09: Excel
          • TP03: Excel (15%)
        • 10: Excel
        • 11: Examen Excel (20%)
        • 12: Access
        • 13: Access
        • 14: Access
        • 15: Examen Access
      • Sondage H2023 (dept. info)
      • Vision H2023 (dept. info)
      • P1) exercices interactifs de lecture
      • P2) transition Excel vers Python
        • Atelier 2: un exemple
      • Jquery
      • Jquery Ui
      • Point de vue sur l'IA
    Structures Generiques02
    • Théorie 3.2: structure générique (2)
      • Utiliser les paramètres de type
      • Erreurs de compilation
      • L’interface Liste avec paramètres de type
      • Implanter Liste avec paramètres de type
      • Il reste une erreur d’exécution!

    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

    Creative Commons License Creative Commons Attribution Creative Commons ShareAlike
    • Théorie 3.2: structure générique (2)
      • Utiliser les paramètres de type
      • Erreurs de compilation
      • L’interface Liste avec paramètres de type
      • Implanter Liste avec paramètres de type
      • Il reste une erreur d’exécution!