Terminale - Programmation Orientée Objet

Exercices

Définir une classe Carre représentant un carré défini par :

• un unique attribut cote
• deux méthodes perimetre et aire, renvoyant respectivement le périmètre et l'aire du carré

>>> carre = Carre(5)
>>> carre.cote
5
>>> carre.perimetre()
20
>>> carre.aire()
25

Définir une classe Rectangle représentant un rectangle défini par :

• deux attributs longueur et largeur
• deux méthodes perimetre et aire, renvoyant respectivement le périmètre et l'aire du rectangle
• une méthode estUnCarre qui renvoie True si le rectangle est un carré, et False sinon

>>> rect = Rectangle(5, 8)
>>> rect.perimetre()
26
>>> rect.aire()
40
>>> rect.estUnCarre()
False

Définir une classe Triangle représentant un triangle défini par :

• trois attributs a, b et c (longueurs des côtés)
• cinq méthodes perimetre, aire, est_isocele, est_equilateral et est_rectangle retournant respectivement le périmètre du triangle, l'aire du triangle (voir la formule de Héron) et True si le triangle est isocèle / équilatéral / rectangle, False sinon

1. Créer une classe Compte modélisant un compte en banque. La classe possède un attribut capital correspondant à la somme placée sur le compte. La création d'un compte doit se faire de la manière suivante :

>>> mon_compte = Compte(200) # Création d'un compte avec 200 euros

2. Implémenter une méthode afficher() qui affiche le capital disponible :

>>> mon_compte = Compte(200)
>>> mon_compte.afficher()
Compte | 200€

3. Implémenter une méthode deposer(x) qui ajoute x au capital disponible sur le compte.

>>> mon_compte = Compte(200)
>>> mon_compte.deposer(50)
>>> mon_compte.afficher()
Compte | 250€

4. Implémenter une méthode retirer(x) qui enlève x au capital disponible sur le compte. Elle pourra afficher une erreur si la somme sur le compte devient négative et annuler alors l'opération.

>>> mon_compte = Compte(200)
>>> mon_compte.retirer(150)
>>> mon_compte.afficher()
Compte | 50€
>>> mon_compte.retirer(80)
Opération non permise : Solde insuffisant
>>> mon_compte.afficher()
Compte | 50€

Pour "afficher une erreur", il suffit de faire un print dans la méthode...

1. La classe Point
   1. Créer une classe Point modélisant un point dans un plan, à l'aide de ses deux coordonnées. La classe possède deux attributs x et y correspondant aux coordonnées du point.

   >>> A = Point(1,2) # Création du point A(1;2)

   2. Implémenter une méthode distance(point) retournant la distance entre le point et un second point passé en argument.

   >>> A = Point(1,2)
   >>> B = Point(-2,1)
   >>> A.distance(B)
   3.1622776601683795

   La distance entre deux points $A(x_A;y_A)$ et $B(x_B;y_B)$ est donnée par $\sqrt{(x_B-x_A)^2 + (y_B-y_A)^2}$
2. La classe Cercle
   1. Créer une classe Cercle modélisant un cercle dans le plan, caractérisé par son centre (un objet de type Point) et son rayon (un flottant positif). La classe possède deux attributs centre et rayon.

   >>> A = Point(1,2)
   >>> C1 = Cercle(A, 3) # Cercle de centre A(1;2) et de rayon 3

   2. Implémenter une méthode booléenne contient(point), qui retourne True si point est dans (ou sur) le cercle, et False sinon.

      >>> A = Point(1,2)
      >>> C1 = Cercle(A, 3)
      >>> B = Point(0,0)
      >>> C1.contient(B)
      True

On souhaite modéliser les différents appartements qui composent un immeuble.
Chaque appartement est composé de plusieurs pièces, et l’immeuble contient plusieurs appartements.

On se propose de créer 3 classes - Piece, Appartement et Immeuble - chacune possédant des attributs et des méthodes propres, permettant notamment de calculer des surfaces.

1. La classe Piece
Créer une classe Piece modélisant une pièce d'un appartement, caractérisée par son nom et sa surface en m$^2$.

>>> salle_de_bains = Piece("salle de bains", 4.5) # Une salle de bains de 4,5 mètres carrés

2. La classe Appartement

On considère la classe Appartement décrite par le code ci-dessous :

class Appartement:

    def __init__(self, numero, etage):
        self.numero = numero
        self.etage = etage
        self.pieces = []

    def ajouter_piece(self, piece : Piece): # piece : Piece signifie que piece est un objet de type Piece
        self.pieces.append(piece)

Voici un exemple de création d'objet de type Appartement avec l'ajout de plusieurs pièces:

app = Appartement(3,1)
app.ajouter_piece(Piece("Salon", 18))
app.ajouter_piece(Piece("Chambre 1", 11))
app.ajouter_piece(Piece("Chambre 2", 13))
app.ajouter_piece(Piece("Cuisine", 10))
app.ajouter_piece(Piece("Salle de bains", 5))

Pour ajouter une pièce comme le salon, on aurait pu faire salon = Piece("Salon", 18) puis app.ajouter_piece(salon).
1. Implémenter une méthode nombre_pieces renvoyant le nombre de pièces composant l'appartement.

>>> app.nombre_pieces()
5

2. Implémenter une méthode surface renvoyant le surface totale de l'appartement.

>>> app.surface()
57

3. La classe Immeuble

On souhaite disposer d'une classe Immeuble répondant au fonctionnement tel que décrit ci-dessous :

# Appartement 1
app1 = Appartement(1, 0)
app1.ajouter_piece(Piece("Salon", 22))
app1.ajouter_piece(Piece("Chambre 1", 12))
app1.ajouter_piece(Piece("Chambre 2", 11))
app1.ajouter_piece(Piece("Cuisine", 9))
app1.ajouter_piece(Piece("Salle de bains", 4))

# Appartement 2
app2 = Appartement(2, 1)
app2.ajouter_piece(Piece("Salon", 18))
app2.ajouter_piece(Piece("Chambre 1", 11))
app2.ajouter_piece(Piece("Chambre 2", 13))
app2.ajouter_piece(Piece("Cuisine", 10))
app2.ajouter_piece(Piece("Salle de bains", 5))

# Appartement 3
app3 = Appartement(3, 2)
app3.ajouter_piece(Piece("Salon", 20))
app3.ajouter_piece(Piece("Chambre", 14))
app3.ajouter_piece(Piece("Cuisine", 8))
app3.ajouter_piece(Piece("Salle de bains", 4))

# Immeuble
mon_immeuble = Immeuble("37 Cours Napoléon")
mon_immeuble.ajouter_appartement(app1)
mon_immeuble.ajouter_appartement(app2)
mon_immeuble.ajouter_appartement(app3)

1. Proposer une implémentation de la classe Immeuble.
2. Écrire une méthode nombre_appartements renvoyant le nombre d'appartements présents dans l'immeuble.

>>> mon_immeuble.nombre_appartements()
3

3. Écrire une méthode surface_totale renvoyant la surface occupée par l'ensemble des appartements, en $m^2$.

>>> mon_immeuble.surface_totale()
161