Les appels en cascade
Dans ce chapitre, nous aborderons le concept des appels en cascade. Ces techniques permettent d’améliorer l’encapsulation de votre code en réduisant la quantité de codes nécessaires pour effectuer certaines opérations. Les appels en cascade consistent à appeler plusieurs méthodes sur un même objet. Ils permettent d’enchaîner les opérations sur un objet en les regroupant de manière plus concise et lisible. Cette approche contribue également à améliorer la compréhension du programme.
Imaginez les appels en cascade comme un système composé d’interrupteurs et d’ampoules. L’utilisateur final ne fait qu’actionner l’interrupteur, sans fournir directement de courant à l’ampoule. En appuyant sur le bouton, le basculement du switch libère le courant et allume l’ampoule. Le diagramme suivant illustre cette situation. Notez que les méthodes allumer() et éteindre() doivent être publiques pour que l’interrupteur puisse les activer. Cependant, nous explorerons ultérieurement comment les dissimuler à l’utilisateur final.
Correction
class Ampoule:
def __init__(self):
self.__allumé = False
def __str__(self):
return "Allumé" if self.__allumé else "Eteinte"
@property
def allumé(self):
return self.__allumé
def allumer(self):
self.__allumé = True
def eteindre(self):
self.__allumé = False
class Interrupteur:
def __init__(self, ampoule):
self.ampoules = [ampoule]
self.etat = ampoule.allumé
def ajouterAmpoule(self, ampoule):
self.ampoules.append(ampoule)
def presser(self):
if self.etat is False:
for ampoule in self.ampoules:
ampoule.allumer()
self.etat = True
else:
for ampoule in self.ampoules:
ampoule.eteindre()
self.etat = False
# Exemple d'utilisation
ampoule = Ampoule()
interrupteur = Interrupteur(ampoule)
print("État de l'ampoule: ", ampoule)
interrupteur.presser()
print("État de l'ampoule: ", ampoule)
interrupteur.presser()
print("État de l'ampoule: ", ampoule)
interrupteur.presser()
print("État de l'ampoule: ", ampoule)#include <iostream>
#include <memory>
#include <vector>
class Ampoule {
public:
Ampoule() : allume(false) {}
std::string toString() const {
return allume ? "Allumé" : "Eteinte";
}
bool estAllume() const {
return allume;
}
void allumer() {
allume = true;
}
void eteindre() {
allume = false;
}
private:
bool allume;
};
class Interrupteur {
public:
Interrupteur(std::shared_ptr<Ampoule> ampoule) : etat(ampoule->estAllume()) {
ampoules.push_back(ampoule);
}
void ajouterAmpoule(std::shared_ptr<Ampoule> ampoule) {
ampoules.push_back(ampoule);
}
void presser() {
etat = !etat;
for (auto& ampoule : ampoules) {
etat ? ampoule->allumer() : ampoule->eteindre();
}
}
private:
std::vector<std::shared_ptr<Ampoule>> ampoules;
bool etat;
};
int main() {
auto ampoule = std::make_shared<Ampoule>();
Interrupteur interrupteur(ampoule);
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
interrupteur.presser();
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
interrupteur.presser();
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
interrupteur.presser();
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
return 0;
}using System;
using System.Collections.Generic;
public class Ampoule
{
private bool allume;
public Ampoule()
{
allume = false;
}
public override string ToString()
{
return allume ? "Allumé" : "Eteinte";
}
public bool Allume
{
get { return allume; }
}
public void Allumer()
{
allume = true;
}
public void Eteindre()
{
allume = false;
}
}
public class Interrupteur
{
private List<Ampoule> ampoules;
private bool etat;
public Interrupteur(Ampoule ampoule)
{
ampoules = new List<Ampoule> { ampoule };
etat = ampoule.Allume;
}
public void AjouterAmpoule(Ampoule ampoule)
{
ampoules.Add(ampoule);
}
public void Presser()
{
if (!etat)
{
foreach (Ampoule ampoule in ampoules)
{
ampoule.Allumer();
}
etat = true;
}
else
{
foreach (Ampoule ampoule in ampoules)
{
ampoule.Eteindre();
}
etat = false;
}
}
}
public class Program
{
public static void Main(string[] args)
{
Ampoule ampoule = new Ampoule();
Interrupteur interrupteur = new Interrupteur(ampoule);
Console.WriteLine("État de l'ampoule: " + ampoule);
interrupteur.Presser();
Console.WriteLine("État de l'ampoule: " + ampoule);
interrupteur.Presser();
Console.WriteLine("État de l'ampoule: " + ampoule);
interrupteur.Presser();
Console.WriteLine("État de l'ampoule: " + ampoule);
}
}
Nous pouvons aussi appeler plusieurs méthodes les unes après les autres sans limites. Reprenons notre exemple d’ampoule, l’utilisateur actionne toujours l’interrupteur, mais le processus implique désormais un câble pour transmettre le courant. Lorsque l’utilisateur appuie sur l’interrupteur, le courant est libéré et circule à travers le câble, permettant ainsi d’allumer l’ampoule. Cette configuration ajoute une couche supplémentaire d’interaction entre les éléments du système, mais met en évidence l’importance de la coordination et de la communication entre les différentes parties pour assurer un fonctionnement harmonieux.
Correction
class Ampoule:
def __init__(self):
self.__allumé = False
def __str__(self):
return "Allumé" if self.__allumé else "Eteinte"
@property
def allumé(self):
return self.__allumé
def allumer(self):
self.__allumé = True
def eteindre(self):
self.__allumé = False
class Câble:
def __init__(self, ampoule):
self.__état = False
self.__ampoules = [ampoule]
def ajouterAmpoule(self, ampoule):
self.__ampoules.append(ampoule)
def basculer(self):
if self.__état is False:
for ampoule in self.__ampoules:
ampoule.allumer()
self.__état = True
else:
for ampoule in self.__ampoules:
ampoule.eteindre()
self.__état = False
class Interrupteur:
def __init__(self, câble):
self.__câble = câble
def presser(self):
self.__câble.basculer()
# Exemple d'utilisation
ampoule = Ampoule()
câble = Câble(ampoule)
interrupteur = Interrupteur(câble)
print("État de l'ampoule: ", ampoule)
interrupteur.presser()
print("État de l'ampoule: ", ampoule)
interrupteur.presser()
print("État de l'ampoule: ", ampoule)
interrupteur.presser()
print("État de l'ampoule: ", ampoule)#include <iostream>
#include <memory>
#include <vector>
class Ampoule {
public:
Ampoule() : allume(false) {}
std::string toString() const {
return allume ? "Allumé" : "Eteinte";
}
bool estAllume() const {
return allume;
}
void allumer() {
allume = true;
}
void eteindre() {
allume = false;
}
private:
bool allume;
};
class Cable {
public:
Cable(std::shared_ptr<Ampoule> ampoule) : etat(false) {
ampoules.push_back(ampoule);
}
void ajouterAmpoule(std::shared_ptr<Ampoule> ampoule) {
ampoules.push_back(ampoule);
}
void basculer() {
etat = !etat;
for (auto& ampoule : ampoules) {
if (etat) {
ampoule->allumer();
} else {
ampoule->eteindre();
}
}
}
private:
bool etat;
std::vector<std::shared_ptr<Ampoule>> ampoules;
};
class Interrupteur {
public:
Interrupteur(std::shared_ptr<Cable> cable) : cable(cable) {}
void presser() {
cable->basculer();
}
private:
std::shared_ptr<Cable> cable;
};
int main() {
auto ampoule = std::make_shared<Ampoule>();
auto cable = std::make_shared<Cable>(ampoule);
Interrupteur interrupteur(cable);
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
interrupteur.presser();
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
interrupteur.presser();
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
interrupteur.presser();
std::cout << "État de l'ampoule: " << ampoule->toString() << std::endl;
return 0;
}using System;
using System.Collections.Generic;
class Ampoule
{
private bool allumé;
public Ampoule()
{
allumé = false;
}
public override string ToString()
{
return allumé ? "Allumé" : "Eteinte";
}
public bool Allumé
{
get { return allumé; }
}
public void Allumer()
{
allumé = true;
}
public void Eteindre()
{
allumé = false;
}
}
class Câble
{
private bool état;
private List<Ampoule> ampoules;
public Câble(Ampoule ampoule)
{
état = false;
ampoules = new List<Ampoule> { ampoule };
}
public void AjouterAmpoule(Ampoule ampoule)
{
ampoules.Add(ampoule);
}
public void Basculer()
{
état = !état;
foreach (Ampoule ampoule in ampoules)
{
if (état)
ampoule.Allumer();
else
ampoule.Eteindre();
}
}
}
class Interrupteur
{
private Câble câble;
public Interrupteur(Câble câble)
{
this.câble = câble;
}
public void Presser()
{
câble.Basculer();
}
}
class Program
{
static void Main(string[] args)
{
Ampoule ampoule = new Ampoule();
Câble câble = new Câble(ampoule);
Interrupteur interrupteur = new Interrupteur(câble);
Console.WriteLine("État de l'ampoule: " + ampoule);
interrupteur.Presser();
Console.WriteLine("État de l'ampoule: " + ampoule);
interrupteur.Presser();
Console.WriteLine("État de l'ampoule: " + ampoule);
interrupteur.Presser();
Console.WriteLine("État de l'ampoule: " + ampoule);
}
}