Programmation orientée objet → Exercice: Vos premières méthodes

Exercice: Vos premières méthodes

Le but de cet exercice est de vous familiariser avec la conception de classes, la gestion des attributs et l’implémentation de méthodes en programmation orientée objet. Vous devrez déterminer le type de méthode et leur visibilité appropriée pour chaques attributs et méthodes demandées. Cela vous permettra de mieux comprendre comment organiser et structurer votre code pour qu’il soit modulaire, réutilisable et facile à maintenir.

Le chronomètre

Dans cet exercice, nous allons simuler le fonctionnement d’un chronomètre à l’aide de la programmation orientée objet. L’objectif de cet exercice est de créer une classe Chronomètre qui représente un chrono et de gérer l’avancement de l’aiguille si l’utilisateur a lancé le chronomètre. L’utilisateur pourra également arrêter ou réinitialiser son chrono.

Créez une classe Chronomètre avec les attributs suivant:
1. Status: un booléen permettant de savoir si le chrono a démarré ou pas
2. Compteur: Représente l’avancement de l’aiguille.
Implémentez les méthodes suivantes:
1. start(): qui permet à l’utilisateur de signaler qu’il souhaite commencer d’enregistrer le temps.
2. stop(): qui arrête l’enregistrement du temps dans le chronomètre.
3. reset(): qui réinitialise l’aiguille sur zéro.
4. tick(): qui représente l’horloge interne du chronomètre. La fonction tick() doit être appelée régulièrement et avancera le compteur si le chrono a été démarré.

Correction

Python

class Chronomètre:
  def __init__(self, status=False):
    self.__compteur = 0
    self.__status = status

  @property
  def compteur(self):
    return self.__compteur

  def start(self):
    self.__status = True

  def stop(self):
    self.__status = False

  def reset(self):
    self.__compteur = 0

  def tick(self):
    if self.__status:
      self.__compteur = self.__compteur + 1

c = Chronomètre()
c.tick()
c.tick()

c.start()
c.tick()
c.tick()
c.tick()
c.stop()

c.tick()
print(c.compteur)
c.reset()
print(c.compteur)

C++

#include <iostream>

class Chronometre {
public:
    Chronometre(bool status = false)
        : compteur_(0), status_(status) {}

    int getCompteur() const {
        return compteur_;
    }

    void start() {
        status_ = true;
    }

    void stop() {
        status_ = false;
    }

    void reset() {
        compteur_ = 0;
    }

    void tick() {
        if (status_) {
            ++compteur_;
        }
    }

private:
    int compteur_;
    bool status_;
};

int main() {
    Chronometre c;
    c.tick();
    c.tick();

    c.start();
    c.tick();
    c.tick();
    c.tick();
    c.stop();

    c.tick();
    std::cout << c.getCompteur() << std::endl;
    c.reset();
    std::cout << c.getCompteur() << std::endl;

    return 0;
}

using System;

public class Chronometre
{
    private int _compteur;
    private bool _status;

    public Chronometre(bool status = false)
    {
        _compteur = 0;
        _status = status;
    }

    public int Compteur
    {
        get { return _compteur; }
    }

    public void Start()
    {
        _status = true;
    }

    public void Stop()
    {
        _status = false;
    }

    public void Reset()
    {
        _compteur = 0;
    }

    public void Tick()
    {
        if (_status)
        {
            _compteur = _compteur + 1;
        }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Chronometre c = new Chronometre();
        c.Tick();
        c.Tick();

        c.Start();
        c.Tick();
        c.Tick();
        c.Tick();
        c.Stop();

        c.Tick();
        Console.WriteLine(c.Compteur);
        c.Reset();
        Console.WriteLine(c.Compteur);
    }
}

Le Feu Rouge

Dans cet exercice, nous allons simuler le fonctionnement d’un feu de signalisation routière à l’aide de la programmation orientée objet. L’objectif de cet exercice est de créer une classe FeuRouge qui représente un feu de signalisation et de gérer les changements d’état en fonction du temps. Lorsque le compteur atteint zéro (le temps restant), le feu doit automatiquement changer d’état et réinitialiser ce compteur.

Créez une classe FeuRouge avec les attributs suivants :
1. Couleur: L’état actuel du feu (rouge, orange ou vert).
2. Compteur: Représente le temps restant avant le changement d’état.
3. DuréeRouge, duréeOrange, duréeVert: Représentant les temps de base avant le changement d’état.
Implémentez les méthodes suivantes :
1. tick() qui réduit le compteur d’une seconde, lorsque le compteur passe à zéro, changez la couleur du feu, puis réinitialiser le compteur selon la couleur du feu.
2. reset() qui réinitialise le compteur selon la couleur du feu.

Correction

Python

import time

class FeuRouge:
  def __init__(self):
    self.__couleur = "rouge"
    self.__duréeRouge = 30
    self.__duréeOrange = 5
    self.__duréeVert = 25
    self.__compteur = self.__duréeRouge

  @property
  def couleur(self):
    return self.__couleur

  def __reset(self):
    if self.__couleur == "rouge":
      self.__compteur = self.__duréeRouge
    if self.__couleur == "orange":
      self.__compteur = self.__duréeOrange
    if self.__couleur == "vert":
      self.__compteur = self.__duréeVert
    

  def tick(self):
    self.__compteur = self.__compteur - 1
    if self.__compteur == 0:
      
      if self.__couleur == "rouge":
        self.__couleur = "vert"
      elif  self.__couleur == "orange":
        self.__couleur = "rouge"
      elif  self.__couleur == "vert":
        self.__couleur = "orange"
      
      self.__reset()


feu = FeuRouge()
lastColor = feu.couleur
while True:
  feu.tick()
  if lastColor != feu.couleur:
    print(feu.couleur)

  lastColor = feu.couleur
  time.sleep(0.1)

C++

#include <iostream>
#include <string>
#include <thread>
#include <chrono>

class FeuRouge {
public:
    FeuRouge() : couleur("rouge"), dureeRouge(30), dureeOrange(5), dureeVert(25), compteur(dureeRouge) {}

    std::string getCouleur() const {
        return couleur;
    }

    void tick() {
        compteur--;
        if (compteur == 0) {
            if (couleur == "rouge") {
                couleur = "vert";
            } else if (couleur == "orange") {
                couleur = "rouge";
            } else if (couleur == "vert") {
                couleur = "orange";
            }
            reset();
        }
    }

private:
    void reset() {
        if (couleur == "rouge") {
            compteur = dureeRouge;
        } else if (couleur == "orange") {
            compteur = dureeOrange;
        } else if (couleur == "vert") {
            compteur = dureeVert;
        }
    }

    std::string couleur;
    int dureeRouge;
    int dureeOrange;
    int dureeVert;
    int compteur;
};

int main() {
    FeuRouge feu;
    std::string lastColor = feu.getCouleur();
    while (true) {
        feu.tick();
        if (lastColor != feu.getCouleur()) {
            std::cout << feu.getCouleur() << std::endl;
        }
        lastColor = feu.getCouleur();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    return 0;
}

using System;
using System.Threading;

public class FeuRouge
{
    private string _couleur;
    private int _dureeRouge = 30;
    private int _dureeOrange = 5;
    private int _dureeVert = 25;
    private int _compteur;

    public FeuRouge()
    {
        _couleur = "rouge";
        _compteur = _dureeRouge;
    }

    public string Couleur
    {
        get { return _couleur; }
    }

    private void Reset()
    {
        if (_couleur == "rouge")
            _compteur = _dureeRouge;
        if (_couleur == "orange")
            _compteur = _dureeOrange;
        if (_couleur == "vert")
            _compteur = _dureeVert;
    }

    public void Tick()
    {
        _compteur -= 1;
        if (_compteur == 0)
        {
            if (_couleur == "rouge")
                _couleur = "vert";
            else if (_couleur == "orange")
                _couleur = "rouge";
            else if (_couleur == "vert")
                _couleur = "orange";

            Reset();
        }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        FeuRouge feu = new FeuRouge();
        string lastColor = feu.Couleur;
        while (true)
        {
            feu.Tick();
            if (lastColor != feu.Couleur)
            {
                Console.WriteLine(feu.Couleur);
            }

            lastColor = feu.Couleur;
            Thread.Sleep(100);
        }
    }
}

Exercice: Vos premières méthodes

Le chronomètre

Le Feu Rouge

Login with your site account

Register a new account