[Précédent]
[Index] | [Enoncé] | [Version imprimable]
[Prochain]

9.3
   Calcul de surfaces 2 - Corrigé
Niveau 1
  
 
Fichiers:
   Surfaces.java     

  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
 
// Ce programme calcule la surface d'un terrain composé d'un nombre arbitraire
// de rectangles et de cercles.
class Surfaces {
    public static void main (String[] args) {
        // Construction d'un terrain:
        Terrain t = new Terrain();

        t.ajouterForme(new Rectangle(100, 100));
        t.ajouterForme(new Cercle(50));

        t.afficherSurfaceTotale();
    }
}

class Terrain {

    // Tableau contenant les formes de ce terrain
    private Forme[] liste;
    // Cette variable indique combien il y a d'éléments dans le tableau
    private int nbFormes = 0;

    public Terrain () {
        liste = new Forme[10];
    }

    /**
     * Ajoute une nouvelle Forme à la liste.
     * @return true si la Forme a pu être ajoutée, false si le terrain est plein
     */
    public boolean ajouterForme(Forme forme) {
        if (nbFormes < liste.length) {
            liste[nbFormes] = forme;
            nbFormes++;
            return true;
        } else {
            return false;
        }
    }

    /**
     * Calcule la surface totale de toutes les formes
     * @return La surface totale
     */
    private double calculerSurfaceTotale () {
        double somme = 0.0;
        for (int i = 0; i < nbFormes; i++) {
            somme += liste[i].calculerSurface();
        }
        return somme;
    }

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

/**
 * Cette classe est la super-classe commune de toutes les formes géométriques.
 * Pour chaque forme (c'est-à-dire pour chaque sous-classe potentielle), on aimerait
 * pouvoir calculer la surface de celle-ci. Comme ce concept est abstrait dans le cas
 * d'une forme géométrique générale, on déclare la classe comme étant abstraite.
 */
abstract class Forme {
    /**
     * Cette méthode calcule la surface d'une forme géométrique. La responsabilité
     * de l'implémentation est laissée aux sous-classes.
     * @return  La surface de la forme
     */
    public abstract double calculerSurface();
}

class Rectangle extends Forme {

    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 extends Forme {

    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);
    }
}

 

[Précédent]
[Index] | [Enoncé] | [Version imprimable]
[Prochain]