Correction 7:
Introduction aux objets

Exercice 1: Conception d'un programme OO simple (POO de base, 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: Calcul de surfaces (POO de base, Niveau 1)

Il s'agit ici de modifier le codage de la classe Terrain de sorte à décrire un terrain non plus comme étant constitué de 2 rectangles mais de 3 rectangles et 2 cercles. Commençons par décrire la nouvelle classe, Cercle qui nous est nécessaire : 

class Cercle {

    private double rayon;

    public Cercle (double rayon) {
        this.rayon = rayon;
    }

    public void setRayon (double rayon) {
        this.rayon = rayon;
    }

    public double getRayon () {
        return rayon;
    }

    public double calculerSurface () {
        return (Math.PI * rayon * rayon);
    }

}

Il faut ensuite mettre à jour la classe Terrain en lui ajoutant les 3 attributs supplémentaires, en modifiant son constructeur et en modifier sa méthode de calcul de surface. On voit que cette dernière modification est complètement transparente pour l'utilisateur externe de la classe Terrain. Les méthodes par lesquelles il interagit avec cette classe (interface d'utilisation ou API) restent inchangées (à part le constructeur). La méthode calculerSurfaceTotale qui a été modifiée est en effet privée et la méthode d'affichage, publique parce qu'utile à l'utilisateur externe, n'a pas été modifiée. 

class Terrain {

    private Rectangle r1;
    private Rectangle r2;
    private Rectangle r3;
    private Cercle c1;
    private Cercle c2;

    public Terrain (double l1, double h1, double l2, double h2, double l3, double h3,
                double rayon1, double rayon2) {

        // Construction des 3 rectangles definissant le terrain:
        r1 = new Rectangle(l1, h1);
        r2 = new Rectangle(l2, h2);
        r3 = new Rectangle(l3, h3);
        c1 = new Cercle(rayon1);
        c2 = new Cercle(rayon2);
    }

    private double calculerSurfaceTotale () {
        return r1.calculerSurface() + r2.calculerSurface() + r3.calculerSurface()
                    + c1.calculerSurface() + c2.calculerSurface();
    }

    public void afficherSurfaceTotale () {
        double surfaceTotale = calculerSurfaceTotale();
        System.out.println("La surface totale est " + surfaceTotale);
    }
}

Voici le code complet du programme modifié: 

 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
 
/* Ce programme calcule la surface d'un terrain composé de 3
 * rectangles et de 2 cercles.
 */
class Surfaces {

    public static void main (String[] args) {
        // Construction d'un terrain:
        Terrain t = new Terrain(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
        t.afficherSurfaceTotale();
    }
}

class Terrain {

    private Rectangle r1;
    private Rectangle r2;
    private Rectangle r3;
    private Cercle c1;
    private Cercle c2;

    public Terrain (double l1, double h1, double l2, double h2, double l3,
                double h3, double rayon1, double rayon2) {
        // Construction des 3 rectangles définissant le terrain:
        r1 = new Rectangle(l1, h1);
        r2 = new Rectangle(l2, h2);
        r3 = new Rectangle(l3, h3);
        c1 = new Cercle(rayon1);
        c2 = new Cercle(rayon2);
    }

    private double calculerSurfaceTotale () {
        return r1.calculerSurface() + r2.calculerSurface() + r3.calculerSurface() +
                    c1.calculerSurface() + c2.calculerSurface();
    }

    public void afficherSurfaceTotale () {
        double surfaceTotale = calculerSurfaceTotale();
        System.out.println("La surface totale est " + surfaceTotale + ".");
    }
}

class Rectangle {

    private double largeur;
    private double hauteur;

    public Rectangle (double largeur, double hauteur) {
        this.largeur = largeur;
        this.hauteur = hauteur;
    }

    public void setLargeur (double largeur) {
        this.largeur = largeur;
    }

    public double getLargeur () {
        return largeur;
    }

    public void setHauteur (double hauteur) {
        this.hauteur = hauteur;
    }

    public double getHauteur () {
        return hauteur;
    }

    public double calculerSurface () {
        return (largeur * hauteur);
    }
}

class Cercle {

    private double rayon;

    public Cercle (double rayon) {
        this.rayon = rayon;
    }

    public void setRayon (double rayon) {
        this.rayon = rayon;
    }

    public double getRayon () {
        return rayon;
    }

    public double calculerSurface () {
        return (Math.PI * rayon * rayon);
    }
}


Exercice 4: Tutorial IntelliJ 7 : Activer la vue Outline (IntelliJ, Niveau 0)

Cet exercice ne nécessite pas de corrigé

Exercice 5: Banque (Transformation d'un programme non OO en un programme OO, POO de base, Niveau 2)

Le code complet est donné 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
 
/* Version orientée objets de Banque1. */

class Banque2 {

    public static void main(String[] args) {
        // Variables locales pour les taux d'intérets (afin d'éviter de
        // répéter les mêmes chiffres pour chaque client):
        double taux1 = 0.01;
        double taux2 = 0.02;

        // Construction des deux clients:
        Client c1 = new Client("Pedro", "Genève", taux1, 1000.0, taux2, 2000.0);
        Client c2 = new Client("Alexandra", "Lausanne", taux1, 3000.0, taux2, 4000.0);

        System.out.println("Donnees avant le bouclement des comptes:");
        c1.afficher();
        c2.afficher();

        // Bouclement des comptes des deux clients:
        c1.boucler();
        c2.boucler();

        System.out.println("Donnees apres le bouclement des comptes:");
        c1.afficher();
        c2.afficher();
    }
}

class Client {

    private String nom;
    private String ville;
    private Compte cpt1;
    private Compte cpt2;

    public Client(String nom, String ville, double taux1, double solde1,
                double taux2, double solde2) {
        this.nom = nom;
        this.ville = ville;
        // Construction d'un compte privé:
        cpt1 = new Compte(taux1, solde1);
        // Construction d'un compte d'épargne:
        cpt2 = new Compte(taux2, solde2);
    }

    public void afficher() {
        // Cette méthode affiche les données du client
        System.out.println("   Client " + nom + " de " + ville);
        System.out.println("      Compte prive:     "
                    + cpt1.getSolde() + " francs");
        System.out.println("      Compte d'epargne: "
                    + cpt2.getSolde() + " francs");
    }

    public void boucler() {
        // Cette méthode boucle les deux comptes du client
        cpt1.boucler();
        cpt2.boucler();
    }
}

class Compte {

    private double taux;
    private double solde;

    public Compte(double taux, double solde) {
        this.taux = taux;
        this.solde = solde;
    }

    public double getSolde() {
        return solde;
    }

    public void boucler() {
        // Cette méthode ajoute les intérets au solde
        double interets = taux * solde;
        solde = solde + interets;
    }
}


Banque avec des clientes (Niveau 1) 

 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
 
class Banque3 {

    public static void main(String[] args) {
        // ... comme avant

        // Construction des deux clients, notez l'argument booléen:
        // Nouveau (parmètre booléen)
        Client c1 = new Client("Pedro", "Geneve", taux1, 1000.0, taux2, 2000.0, true);
        Client c2 = new Client("Alexandra", "Lausanne", taux1, 3000.0, taux2, 4000.0, false);

        // ... comme avant
    }
}

class Client {

    private String nom;
    private String ville;
    private Compte cpt1, cpt2;
    // Nouvelle variable d'instance
    private boolean masculin;

    // Méthode constructeur, notez le paramètre booléen:
    public Client(String nom, String ville, double taux1, double solde1,
                double taux2, double solde2, boolean masculin) {  // Nouveau
        this.nom = nom;
        this.ville = ville;
        cpt1 = new Compte(taux1, solde1);
        cpt2 = new Compte(taux2, solde2);
        // Nouveau
        this.masculin = masculin;
    }

    public void afficher() {
        // Nouvelle instruction if..else
        if (masculin) {
            System.out.print("   Client ");
        } else {
            System.out.print("   Cliente ");
        }
        System.out.println(nom + " de " + ville);
        System.out.println("      Compte prive:     " +
                cpt1.getSolde() + " francs");
        System.out.println("      Compte d'epargne: " +
                cpt2.getSolde() + " francs");
    }
    // ... comme avant
}

class Compte {
    // ... comme avant
}

Exercice 6: Géométrie (POO de base, Niveau 2)

  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
 
import java.util.Scanner;

class Geometrie {

/**
 * Le programme principal se content de construire un
 * triangle, d'afficher son périmètre et d'afficher
 * s'il est isocèle ou non.
 */
    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        Triangle t = new Triangle(lirePoint(), lirePoint(), lirePoint());
        double perimetre = t.calculerPerimetre();
        System.out.println("Perimetre : " + perimetre);
        boolean isocele = t.testerIsocele();
        if (isocele)
            System.out.println("Le triangle est isocele");
        else
            System.out.println("Le triangle nést pas isocele");
    }
    
    // une méthode auxiliaire de main
    static Point lirePoint() {
        double x = 0;
        double y = 0;
        System.out.println("Construction d'un nouveau point");
        System.out.print("   Veuillez entrer x : ");
        x = scanner.nextDouble();
        System.out.print("   Veuillez entrer y : ");
        y = scanner.nextDouble();
        return (new Point(x,y));
    }
}


class Triangle {

    private Point p1, p2, p3;
    private double longueur1, longueur2, longueur3;

    /**
     * Le constructeur d'un Triangle fait appel
     * au constructeur de Point. Ce dernier lit les
     * coordonnées depuis le terminal.
     */
    public Triangle(Point point1, Point point2, Point point3) {
        // Construction de trois points:
        p1 = point1;
        p2 = point2;
        p3 = point3;
        // Les distances sont calculées et stockées dans des variables
        // d'instance. Les méthodes calculerPerimetre et testerIsocele
        // peuvent ainsi accéder aux valeurs précalculées et nous évitons
        // de les recalculer plusieurs fois.
        longueur1 = p1.calculerDistance(p2);
        longueur2 = p2.calculerDistance(p3);
        longueur3 = p3.calculerDistance(p1);
    }

    /**
     * Calcul du perimètre de l'instance courante (this).
     * @return le perimetre sous la forme d'un double
     */
    public double calculerPerimetre() {
        return (longueur1 + longueur2 + longueur3);
    }

    /**
     * Teste si l'instance courante (this) est un triangle isocèle
     * @return true si le triangle est isocèle et false sinon
     */
    public boolean testerIsocele() {
        return (longueur1 == longueur2
                    || longueur2 == longueur3
                    || longueur3 == longueur1);
    }
}



class Point {

    private double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    /**
     * Calcule la distance entre this et un point p
     * @param p un Point par rapport auquel on calcule la distance
     * @return la distance de this à p
     */
    public double calculerDistance(Point p) {
        // Calcule la distance entre deux points. Le premier point est
        // l'objet actuel (this). Le deuxième point (p) est envoyé en
        // paramètre.
        double x1 = this.x;
        double y1 = this.y;

        double x2 = p.getX();
        double y2 = p.getY();

        double xdiff = x1 - x2;
        double ydiff = y1 - y2;

        double somme = xdiff * xdiff + ydiff * ydiff;
        double distance = Math.sqrt(somme);

        return distance;
    }
}


Exercice 7: Supermarché (poo de base, Niveau 2)

  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
 
import java.util.ArrayList;
import java.util.Date;
import java.text.SimpleDateFormat;

class Article {

    private String nom;
    private double prix;
    private boolean action;

    public Article(String nom, double prix, boolean action) {
        this.nom = nom;
        this.prix = prix;
        this.action = action;
    }

    public double getPrix() {
        return prix;
    }

    public String getNom() {
        return nom;
    }

    public boolean estEnAction() {
        return action;
    }

}

class Achat {

    private Article article;
    private int quantite;

    public Achat(Article article, int quantite) {
        this.article = article;
        this.quantite = quantite;
    }

    public double getPrix() {
        double rabais = 1.0;
        if (article.estEnAction()) {
            rabais = 0.5;
        }
        return quantite * article.getPrix() * rabais;
    }

    public void affiche() {
        String nom = article.getNom();
        double prixUnite = article.getPrix();
        double prixTotal = getPrix();
        String rabais = "";

        if (article.estEnAction()) {
            rabais = " (1/2 prix)";
        }
        System.out.println(nom + " : " + prixUnite + " x " + quantite + " = " + prixTotal + " Frs" + rabais);
    }

}

class Caisse {

    private int numero;
    private double total;

    public Caisse(int numero, double total) {
        this.numero = numero;
        this.total = total;
    }

    public void totalCaisse() {
        // printf permet de formatter l'affichage (par exemple pour avoir
        // 2 décimale seulement après la virgule)
        // %c signifie que l'argument 'numero' a pour format d'affichage
        // celui d'une chaine de caracteres
        // %.2f signifie que l'argument 'total' a pour format d'affichage
        // une valeur réelle avec 2 décimales après la virgule
        // %n signfie: saut de ligne
        System.out.printf("La caisse numero %c a encaisse %.2f Frs aujourd'hui%n" , numero, total);
    }

    public void scanner(Caddie caddie) {
        System.out.println("=========================================");

        // Affichage de la date courante
        Date dateCourante = new Date();
        SimpleDateFormat formatDate = new SimpleDateFormat("dd/MM/yy");
        System.out.println(formatDate.format(dateCourante));
        
        System.out.println("Caisse numéro " + numero);
        System.out.println();

        int nbAchat = caddie.getNbAchats();
        double montantTotal = 0;
        
        for (int i = 0; i < nbAchat; i++) {
            Achat achat = caddie.getAchat(i);
            double prix = achat.getPrix();
            achat.affiche();
            montantTotal += prix;
            total += prix;
        }

        System.out.println();
        System.out.println("Montant a payer : " + montantTotal + " Frs");
        System.out.println("=========================================");
    }

}

class Caddie {
    // Ce corrigé vous permet de voir un exemple d'utilisation
    // des tableaux dynamiques (juste entrevus en cours)
    // Les tableaux de ce type peuvent avoir une taille qui
    // augmente ou diminue en cours d'exécution (il n'est pas nécessaire
    // de fixer une taille à la création du tableau)

    // listeAchats est un tableau dynamique d'Achats
    private ArrayList<Achat> listeAchats;

    public Caddie() {
        // le constructeur du tableau dynamique est invoqué
        // pour créer le tableau (qui est vide de contenu au départ)
        this.listeAchats = new ArrayList<Achat>();
    }

    public void remplir(Article article, int quantite) {
        Achat achat = new Achat(article, quantite);

        // la méthode add des ArrayList permet de
        // leur ajouter dynamiquement des données en cours
        // d'exécution du programme.
        // la contrepartie de suppression (remove) existe aussi.
        listeAchats.add(achat);
    }

    public Achat getAchat(int index) {
        // l'accès au ieme élément d'un tableau
        // dynamique se fait par la méthode get
        return listeAchats.get(index);
    }

    public int getNbAchats() {
        // les tableaux dynamiques disposent d'une méthode size
        // retournant la taille du tableau
        return listeAchats.size();
    }

}


public class Supermarche {

    public static void main(String[] args) {
        // Les articles vendus dans le supermarché
        Article choufleur = new Article("Chou-fleur extra", 3.50, false);
        Article roman = new Article("Les malheurs de Sophie", 16.50, true);
        Article camembert = new Article("Cremeux 100%MG", 5.80, false);
        Article cdrom = new Article("C++ en trois jours", 48.50, false);
        Article boisson = new Article("Petit-lait", 2.50, true);
        Article petitspois = new Article("Pois surgeles", 4.35, false);
        Article poisson = new Article("Sardines", 6.50, false);
        Article biscuits = new Article("Cookies de grand-mere", 3.20, false);
        Article poires = new Article("Poires Williams", 4.80, false);
        Article cafe = new Article("100% Arabica", 6.90, true);
        Article pain = new Article("Pain d'epautre", 6.90, false);

        // Les caddies du supermarché
        Caddie caddie1 = new Caddie();
        Caddie caddie2 = new Caddie();
        Caddie caddie3 = new Caddie();

        // Les caisses du supermarché
        // le premier argument est le numero de la caisse
        // le second argument est le montant initial de la caisse.
        Caisse caisse1 = new Caisse(1, 0.0);
        Caisse caisse2 = new Caisse(2, 0.0);

        // les clients font leurs achats
        // le second argument de la méthode remplir
        // correspond à une quantité

        // remplissage du 1er caddie
        caddie1.remplir(choufleur, 2);
        caddie1.remplir(cdrom, 1);
        caddie1.remplir(biscuits, 4);
        caddie1.remplir(boisson, 6);
        caddie1.remplir(poisson, 2);

        // remplissage du 2eme caddie
        caddie2.remplir(roman, 1);
        caddie2.remplir(camembert, 1);
        caddie2.remplir(petitspois, 2);
        caddie2.remplir(poires, 2);

        // remplissage du 3eme caddie
        caddie3.remplir(cafe, 2);
        caddie3.remplir(pain, 1);
        caddie3.remplir(camembert, 2);

        // Les clients passent à la caisse
        caisse1.scanner(caddie1);
        caisse1.scanner(caddie2);
        caisse2.scanner(caddie3);
        
        caisse1.totalCaisse();
        caisse2.totalCaisse();
    }
}

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