Correction 8:
Héritage et base du polymorphisme

Exercice 1: Figures géométriques (Héritage, Niveau 0)

Cet exercice ne nécessite pas de corrigé

Exercice 2: MOOC (cours en ligne) (MOOC, Niveau 1)

Cet exercice ne nécessite pas de corrigé

Exercice 3: Que de véhicules (Héritage, Niveau 1)

3.1 La classe Vehicule

Définissez une classe Vehicule qui a pour attributs des informations valables pour tout type de véhicule : sa marque , sa date d'achat, son prix d'achat et son prix courant.

Solution :

class Vehicule {

    private String marque;
    private int dateAchat;
    private double prixAchat;
    private double prixCourant;

Ces attributs sont private pour assurer une bonne encapsulation.

Définissez un constructeur prenant en paramètres la marque, la date d'achat et le prix d'achat.

Une solution possible: :

    public Vehicule(String marque, int date, double prix) {
        this.marque = marque;
        dateAchat = date;
        prixAchat = prix;
        prixCourant = prix;
    }

Définissez une méthode publique affiche() qui affiche la valeur des attributs.

    public void affiche() {
        System.out.print("marque : " + marque
                    + ", date d'achat : " + dateAchat
                    + ", prix actuel : " + prixCourant);
        System.out.println();
    }

3.2 La classe Voiture et la classe Avion

Définissez deux classes Voiture et Avion, héritant de la classe Vehicule et ayant les attributs supplémentaires suivants :

Commençons par la classe Voiture. Elle doit hériter de la classe Vehicule : 

class Voiture extends Vehicule {

On ajoute ensuite les champs spécifiques à la classe Voiture :

    private double cylindree;
    private int nbPortes;
    private double puissance;
    private double kilometrage;

Pour la classe Avion, on procède de même :

class Avion extends Vehicule {
    
    private String moteur;
    private int heuresVol;

Définissez maintenant un constructeur pour Voiture, ainsi qu'une méthode affichant la valeur des attributs.

    public Voiture(String marque, int date, double prix,
                double cylindree, int portes, double cv, double km) {
        super(marque, date, prix);
        this.cylindree = cylindree;
        nbPortes = portes;
        puissance = cv;
        kilometrage = km;
    }
 

    public void affiche() {
        System.out.println(" ---- Voiture ----");
        super.affiche();
        System.out.println(cylindree + " litres, "
                    + nbPortes + " portes, "
                    + puissance + " CV, "
                    + kilometrage + " km.");
    }

Ces deux méthodes doivent, bien entendu, être publiques puisqu'elles sont précisément faites pour être utilisées hors de la classe.

Notez que pour le constructeur de Voiture, on fait appel au constructeur de Vehicule . On fait également appel à la méthode d'affichage de la super-classe dans la méthode affiche de Voiture.

Les méthodes de la classe Avion s'implémentent de même : 

    public Avion(String marque, int date, double prix, String moteur, int heures) {
        super(marque, date, prix);
        this.moteur = moteur;
        heuresVol = heures;
    }
 

    public void affiche() {
        System.out.println(" ---- Avion à " + moteur + "----");
        super.affiche();
        System.out.println(heuresVol + " heures de vol.");
    }

Encore des méthodes

Ajoutez une méthode void calculePrix() dans la classe Vehicule
Le prix doit rester positif (donc s'il est négatif, on le met à 0). 

    public void calculePrix(int anneActuelle) {
        double decote = (anneActuelle - dateAchat) * 0.01;
        prixCourant = Math.max(0.0, (1.0 - decote) * prixAchat);
    }

Redéfinissez cette méthode dans les deux sous-classes Voiture et Avion.

Les entêtes sont les mêmes pour Voiture et Avion que pour Vehicule, par contre les définitions diffèrent.

Voiture: 

public void calculePrix(int anneActuelle) {
    double decote = (anneActuelle - getDateAchat()) * .02;
    // On force le type en int de manière à arrondir le résultat
    // On verra dans quelques semaines une manière plus élégante de faire
    // ce genre de choses...
    decote += 0.05 * (int)(kilometrage / 10000);
    if (getMarque().equals("Fiat") || getMarque().equals("Renault")) {
        decote += 0.1;
    } else if (getMarque().equals("Ferrari") || getMarque().equals("Porsche")) {
        decote -= 0.2;
    }
    setPrixCourant(Math.max(0.0, (1.0 - decote) * getPrixAchat()));
  }

On se rend compte ici que l'on a besoin d'accèder à des attributs privés de la super-classe, ou de les modifier (dateAchat, marque, prixAchat et prixCourant). Il faut donc enrichir la classe Vehicule des "getters/setters" nécessaires :

  public int getDateAchat(){
      return dateAchat;
  }
  public String getMarque(){
      return marque;
  }
  public double getPrixAchat(){
      return prixAchat;
  }
  public void setPrixCourant(double prix){
      prixCourant = prix;
  }

Il aurait été possible de déclarer les attributs nécessaires comme protected dans la classe Vehicule pour s'éviter la peine de définir les getters/setters. Ceci peut cependant nuire à une bonne encapsulation : un autre programmeur peut hériter de votre classe Vehicule. Il aurait alors accès aux détails d'implémentation et vous ne pourriez plus modifier librement cette implémentation sans potentiellement causer du tort à ses programmes ! Voici enfin la méthode calculePrix pour les avions : 

public void calculePrix(int anneActuelle) {
    double decote;
    if (moteur == "HELICES") {
        decote = 0.1 * heuresVol / 100.0;
    } else {
        decote = 0.1 * heuresVol / 1000.0;
    }
    setPrixCourant(Math.max(0.0, (1.0 - decote) * getPrixAchat()));
  }

Pour finir, ceux qui le souhaitent peuvent trouver ici le code complet.

Exercice 4: Héritage de variables (Héritage, Niveau 1)

  1. System.out.println(x.a)
    Correct, car une variable d'instance a est déclarée dans la classe de x (E1).

  2. System.out.println(y.c)
    Faux, car la classe de y (E2) ne dispose pas de la variable d'instance c qui est déclarée dans une sous-classe (E3).

  3. System.out.println(z.b)
    Correct, car la variable d'instance b est héritée de la super-classe (E2) de z (qui est de type E3).

  4. System.out.println(v.e)
    Faux, car la classe de v (E4) ne dispose pas de la variable d'instance e qui est déclarée dans une classe parallèle (E3).

  5. System.out.println(w.a)
    Correct, car la variable d'instance a est héritée d'une super-classe (E1) de w (qui est de type E5).

Exercice 5: EPFLiens (Héritage, Niveau 2)

Le code complet est fourni ci-dessous. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
import java.util.Calendar;
import java.util.ArrayList;

/**
 * Classe principale
   */
class Direction 
{
    public static void main(String[] args) {
        Ecole epfl = new Ecole();
        epfl.add(new EtudiantRegulier("Gaston Peutimide", 2020, "SSC", 6.0));
        epfl.add(new EtudiantRegulier("Yvan Rattrapeur", 2016, "SSC", 2.5));
        epfl.add(new EtudiantEchange("Bjorn Borgue", 2018, "Informatique", "KTH"));
        epfl.add(new Enseignant("Mathieu Matheu", 2015, "LMEP", 10000, "Physique"));
        epfl.add(new  Secretaire("Sophie Scribona", 2005, "LMT", 5000));
        epfl.afficherStatistiques();
        epfl.afficherEPFLiens();
    }

}

 /**
  * La direction
  */

class Ecole {
    private ArrayList<EPFLien> gens;

    public Ecole() {
        gens = new ArrayList<EPFLien>();
    }

    
    public void add(EPFLien personne)
        {
            if (personne != null)
            {
                gens.add(personne);
            }
        }
    
        /**
         * Cette méthode affiche l'ancienneté moyenne des personnes fréquentant  l'école
         * et le nombre d'étudiants parmi eux
         */
    public void afficherStatistiques() {

        System.out.println("Parmi les " + gens.size() + " EPFLiens, " +
                           EPFLien.getNbEtudiants() + " sont des etudiants.");
       
        System.out.println("Ils sont ici depuis en moyenne " + ancienneteMoyenne() + " ans");
    }

    

    // Cette méthode affiche les caractéristiques des personnes fréquentant  l'école
    public void afficherEPFLiens() {
        System.out.println("Liste des EPFLiens: ");
        for (EPFLien epflien : gens)
            epflien.afficher();
    }

    //un méthode utilitaire pour l'affichage des statistiques
    // (ne fait pas partie de l'API)
    private double ancienneteMoyenne()
        {
            if (gens.size() == 0) return 0.0;
            
            int anneeCourante = Calendar.getInstance().get(Calendar.YEAR);
            double moyenne = 0.0;
            
            for (EPFLien epflien : gens){
                moyenne += (anneeCourante - epflien.getAnnee());
            }
            return moyenne / gens.size();
        }
}


/**
  * Les personnes fréquentant l'EPFL
  */
class EPFLien {
    private String nom;
    private int annee;
    // un compteur statique pour compter le nombre d'étudiants
    private static int nombreEtudiants;
    

    public EPFLien(String nom, int annee) {
        this.nom = nom;
        this.annee = annee;
    }
    
   //Cette méthode affiche les caractéristiques générales d'un EPFLien
    public void afficher() {
        System.out.println("   Nom : " + getNom());
        System.out.println("   Annee : " + getAnnee());
    }

    public String getNom() {
        return nom;
    }

    public int getAnnee() {
        return annee;
    }

    public static int getNbEtudiants()
        {
            return nombreEtudiants;
        }
    
    protected void ajoutEtudiant()
        {
            ++nombreEtudiants;
        }
    
}

/**
  * Les étudiants
  */
class Etudiant extends EPFLien {
    private String section;

    public Etudiant(String nom, int annee, String section) {
        super(nom, annee);
        this.section = section;
        ajoutEtudiant();
    }

    public void afficher() {
        super.afficher();
        System.out.println("   Section : " + getSection());
    }

    public String getSection() {
        return section;
    }

}


/**
  * Les étudiants régulier
  */
class EtudiantRegulier extends Etudiant {
    private double moyenne;

    public EtudiantRegulier(String nom, int annee, String section, double moyenne) {
        super(nom, annee, section);
        this.moyenne = moyenne;
    }

    public void afficher() {
        System.out.println("Etudiant regulier:");
        super.afficher();
        System.out.println("   Moyenne : " + moyenne);
    }
}

/**
  * Les étudiants  d'échange
  */
class EtudiantEchange extends Etudiant {
    private String uniOrigine;

    public EtudiantEchange(String nom, int annee, String section, String uniOrigine) {
        super(nom, annee, section);
        this.uniOrigine = uniOrigine;
    }

    public void afficher() {
        System.out.println("Etudiant d'echange:");
        super.afficher();
        System.out.println("   Uni d'origine : " + getUniOrigine());
    }

    public String getUniOrigine() {
        return uniOrigine;
    }
}

/**
  * Le personnel de l'EPFL
  */
class Personnel extends EPFLien {
    private String labo;
    private int salaire;

    public Personnel(String nom, int annee, String labo, int salaire) {
        super(nom, annee);
        this.labo = labo;
        this.salaire = salaire;
    }

    public void afficher() {
        super.afficher();
        System.out.println("   Laboratoire : " + getLabo());
        System.out.println("   Salaire : " + getSalaire());
    }

    public String getLabo() {
        return labo;
    }

    public int getSalaire() {
        return salaire;
    }
}

class Enseignant extends Personnel {
    private String section;

    public Enseignant(String nom, int annee, String labo, int salaire, String section) {
        super(nom, annee, labo, salaire);
        this.section = section;
    }

    public void afficher() {
        System.out.println("Enseignant:");
        super.afficher();
        System.out.println("   Section d'enseignement : " + getSection());
    }

    public String getSection() {
        return section;
    }
}

class Secretaire extends Personnel {
    public Secretaire(String nom, int annee, String labo, int salaire) {
        super(nom, annee, labo, salaire);
    }

    public void afficher() {
        System.out.println("Secretaire:");
        super.afficher();
    }
}


Exercice 6: Boîte aux lettres (Héritage, algorithme, Niveau 2)

Une version possible du corrigé est fournie ci-dessous. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
/* Classe pour représenter le courrier
 */

class Courrier {
    // retourne le montant n'ecessaire pour affranchir le courrier
    // en mode d'exp'edition normal
    
    // on va faire une chose tre`s vilaine parcequ'on ne connait pas les
    // m'ethodes abstraites : on va lui donner un corps arbitrairement
    // d'efini (car on ne sait pas la d'efinir proprement
    // a` ce niveau de la hi'erarchie
    public double affranchirNormal(){return 0;};
    // la bonne solution consiste a` d'eclarer cette m'ethode comme suit:
    // abstract private double affranchirNormal();
    // lorsque vous aurez vu les cours de la semaine prochaine, expliquez pourquoi...
    
    // les attributs (communs aux lettres et colis):
    private double poids;
    private boolean express;
    private String adresse;

    // un constructeur possible pour la classe
    public Courrier(double poids, boolean express, String adresse) {
        this.poids = poids;
        this.express = express;
        this.adresse = adresse;
    }

        // un getter pour le poids (car utile dans les sous-classe)
    public double getPoids() {
        return poids;
    }

    // retourne le montant n'ecessaire pour affranchir le courrier.
    // elle appelle affranchirNormal et retourne le double de ce montant
    // si le mode d'exp'edition est  express ('eviter la duplication du code
    // qui double le montant dans les m'ethodes affranchir-normal
    // des sous-classes)
    public double affranchir() {
        if (! valide())
        {
            return 0;
        }
        else
        {
            double total = affranchirNormal();
            if (express) {
                total *= 2;
            }
            return total;
        }
    }

    // un courrier est invalide si l'adresse de destination est vide
    // methode utilis'ee par Boite::affranchir et
    // Boite::courriersInvalides
    public boolean valide() {
        return adresse.length() > 0;
    }
    
    @Override
    public String toString() {
        String s = "";
        if (!valide())
        {
            s+= "(Courrier  invalide)\n";
        }
        s+= "   Poids : " + poids + " grammes\n";
        s+= "   Express : " + (express ? "oui" : "non") + "\n";
        s+= "   Destination : " + adresse + "\n";
        s+= "   Prix : " + affranchir() + " CHF\n";
        return s;
    }

}

/* Une classe pour repr'esenter les lettres
 */

class Lettre extends Courrier {

    //attributs sp'ecifiques aux lettres:
    private String format = "";

    public Lettre(double poids, boolean express, String adresse, String format){
        super(poids, express, adresse);
        this.format = format;
    }

    // red'efinit affranchirNormal()
    public double affranchirNormal() {
        double montant = 0;
        if (format.equals("A4")){
            montant = 2.0;
        } else {
            montant = 3.5;
        }
        montant += getPoids()/1000.0;
        return montant;
    }

    // inutile de red'efinir la méthode valide() pour les  lettres
    
    @Override
    public String toString() {
        String s = "Lettre\n";
        s += super.toString();
        s += "  Format : " + format + "\n";
        return s;
    }

}
/* Une classe pour repr'esenter les publicit'es
 */

class Publicite extends Courrier {

    public Publicite(double poids, boolean express, String adresse){
        super(poids, express, adresse);
    }

    // redéfinit affranchirNormal()
    public double affranchirNormal() {
        return getPoids()/1000.0 * 5.0;
    }


    // inutile de red'efinir la méthode valide() pour les  publicités

    @Override
    public String toString() {
        String s = "Publicité\n";
        s += super.toString();
        return s;
    }
    
}

/* Une classe pour repr'esenter les colis
 */
class Colis extends Courrier {

    //attributs sp'ecifiques aux colis:
    private double volume;

    public Colis(double poids, boolean express, String adresse, double volume) {
        super(poids, express, adresse);
        this.volume = volume;
    }

    // redéfinit affranchirNormal();
    public double affranchirNormal() {
        // affranchit les colis selon une formule pr'ecise
        return 0.25 * volume + getPoids()/1000.0;
    }

    // ici il faut red'efinir  (sp'ecialiser) la re`gle de validit'e des colis
    // un colis est invalide s' il  a une mauvaise adresse
    //ou depasse un certain volume
    public boolean valide(){
        return (super.valide() && volume <= 50);
    }
    
    @Override
    public String toString() {
        String s = "Colis\n";
        s += super.toString();
        s += "  Volume : " + volume + " litres\n";
        return s;
    }


}

/*   Une classe pour repr'esenter la boite aux lettre
 */

class Boite {

    private Courrier[] contenu;
    private int index;

    // constructeur
    public Boite(int max) {
        contenu = new Courrier[max];
        index = 0;
    }

    // la méthode demand'ee
    public double affranchir() {
        double montant = 0.0;
        for(int i=0; i < index; ++i){
            Courrier c = contenu[i];
            montant += c.affranchir();
        }
        return montant;
    }

    public int size() {
        return index;
    }

    public Courrier getCourrier(int index) {
        if (index < contenu.length)
            return contenu[index];
        else
            return null;
    }

    // autre m'ethode demandée dans l'interface
    // d'utilisation de la classe
    public int courriersInvalides() {
        int count = 0;
        for (int i = 0; i < index; i++) {
            if (!contenu[i].valide())
                count++;
        }
        return count;
    }

    // difficile de fonctionner sans 
    public void ajouterCourrier(Courrier  unCourrier) {
        if (index < contenu.length){
            contenu[index] = unCourrier;
            index++;
        } else {
            System.out.println("Impossible d'ajouter un nouveau courrier. Boite pleine !");
        }
    }
    
    public void afficher() {
        for (int i = 0; i < index; i++) {
            System.out.println(contenu[i]);
        }
    }
    
}


// PROGRAMME PRINCIPAL (non demandé)
class Poste {

    public static void  main(String args[]) {
        //Cr'eation d'une boite-aux-lettres
        Boite boite = new Boite(30);

        //Creation de divers courriers/colis..
        Lettre lettre1 = new Lettre(200, true, "Chemin des Acacias 28, 1009 Pully", "A3");
        Lettre lettre2 = new Lettre(800, false, "", "A4"); // invalide

        Publicite pub1 = new Publicite(1500, true, "Les Moilles  13A, 1913 Saillon");
        Publicite pub2 = new Publicite(3000, false, ""); // invalide

        Colis colis1 = new Colis(5000, true, "Grand rue 18, 1950 Sion", 30);
        Colis colis2 = new Colis(3000, true, "Chemin des fleurs 48, 2800 Delemont", 70); //Colis invalide !

        boite.ajouterCourrier(lettre1);
        boite.ajouterCourrier(lettre2);
        boite.ajouterCourrier(pub1);
        boite.ajouterCourrier(pub2);
        boite.ajouterCourrier(colis1);
        boite.ajouterCourrier(colis2);


        System.out.println("Le montant total d'affranchissement est de " +
                           boite.affranchir());
        boite.afficher();
        
        System.out.println("La boite contient " + boite.courriersInvalides()
                           + " courriers invalides");
    }
}

Exercice 7: Devoir du MOOC (MOOC, Niveau 2)

Cet exercice ne nécessite pas de corrigé

Dernière mise à jour: 08/11/2024  (Revision: 1.2)