Programmation orientée objet → Exercice avancé sur l’héritage

Exercice avancé sur l’héritage

Dans cet exercice, vous allez mettre en pratique les notions d’héritage et de surcharge de méthodes en Python. Vous devez simuler la transmission d’une donnée réseau dans le style TCP/IP. Vous avez à votre disposition un diagramme de classes UML qui modélise les différentes entités impliquées dans la transmission d’une donnée réseau. Votre objectif est de créer le code Python correspondant à ce diagramme.

Voici les principales classes et méthodes à implémenter :

Interface : Cette classe représente une interface réseau. Elle possède deux méthodes principales, envoyer() et recevoir(), ainsi qu’une relation avec la classe Câble. Pour les besoins de cet exercice et pour des raisons de facilité, la méthode recevoir() sera exceptionnellement autorisée à afficher un élément dans la console.
Câble : Cette classe représente un câble reliant deux interfaces. Elle possède une méthode connect(entrée, sortie) pour établir la connexion entre les deux interfaces.
Donnée : Cette classe représente les données transmises sous différentes formes (PacketIP, TrameEthernet et Byte). Elle possède deux méthodes, encapsuler(donnée) et décapsuler(), qui seront surchargées par les classes filles.
PacketIP : Cette classe hérite de Donnée et représente un paquet IP. Elle surcharge les méthodes encapsuler(donnée) et décapsuler(), mais est spécialisée pour les paquets.
TrameEthernet : Cette classe hérite de Donnée et représente une trame Ethernet. Elle surcharge également les méthodes encapsuler(donnée) et décapsuler(), mais est spécialisée pour les trames.
Byte : Cette classe hérite de Donnée et représente un Byte. Elle surcharge aussi les méthodes encapsuler(donnée) et décapsuler(), mais est spécialisée pour les bytes.

Astuces d’implémentation

Utilisez le mot-clé super() pour appeler le constructeur de la classe parente lors de l’initialisation d’une classe fille.
Assurez-vous de bien comprendre le rôle des méthodes encapsuler et décapsuler dans chaque classe, ainsi que la manière dont elles sont surchargées. Prenez en compte les types de données passées en argument et le type de données retournées.
Utilisez des attributs pour stocker les données et les informations relatives à chaque objet (par exemple, l’entête et le payload pour les objets de type Donnée).
Assurez-vous de bien gérer les relations entre les objets, en particulier pour les classes Interface et Câble. Entre autres, lors de la connexion d’un câble à deux interfaces, les objets Interface et Câble doivent être mis à jour en conséquence (en modifiant les attributs cable, entrée et sortie).

Une fois le code implémenté, testez-le en créant deux interfaces, un câble et en envoyant un message d’une interface à l’autre. Le code de test ne fait que ces opérations. L’encapsulation se fait automatiquement dans les méthodes envoyer() et recevoir().

Bon courage !

Correction

class Interface:
    def __init__(self):
        self.cable = None

    def envoyer(self, string):
        packet_ip = PacketIP()
        trame_ethernet = TrameEthernet()
        bytes = Byte()

        packet_ip.encapsuler(string)
        trame_ethernet.encapsuler(packet_ip)
        bytes.encapsuler(trame_ethernet)

        self.cable.sortie.recevoir(bytes)

    def recevoir(self, bytes):
        trame = bytes.decapsuler()
        packet_ip = trame.decapsuler()
        string = packet_ip.decapsuler()
        print(string)


class Cable:
    def __init__(self):
        self.entrée = None
        self.sortie = None

    def connect(self, entrée, sortie):
        self.entrée = entrée
        self.sortie = sortie
        entrée.cable = self
        sortie.cable = self


class Donnee:
    def __init__(self):
        self.entete = None
        self.payload = None

    def encapsuler(self):
        pass

    def decapsuler(self):
        return self.payload


class PacketIP(Donnee):
    def __init__(self):
        super().__init__()
        self.entete = "IP"

    def encapsuler(self, string):
        self.payload = string


class TrameEthernet(Donnee):
    def __init__(self):
        super().__init__()
        self.entete = "ETH"

    def encapsuler(self, packet_ip):
        self.payload = packet_ip


class Byte(Donnee):
    def __init__(self):
        super().__init__()
        self.entete = "Byte"

    def encapsuler(self, trame_ethernet):
        self.payload = trame_ethernet

interface_in = Interface()
interface_out = Interface()

cable = Cable()
cable.connect(interface_in, interface_out)

interface_in.envoyer("Hello World!")

#include <iostream>
#include <memory>
#include <string>

class Donnee {
public:
    std::string entete;
    std::shared_ptr<void> payload;

    virtual void encapsuler(std::shared_ptr<void> data) = 0;
    virtual std::shared_ptr<void> decapsuler() = 0;
};

class PacketIP : public Donnee {
public:
    PacketIP() {
        entete = "IP";
    }

    void encapsuler(std::shared_ptr<void> data) override {
        payload = data;
    }

    std::shared_ptr<void> decapsuler() override {
        return payload;
    }
};

class TrameEthernet : public Donnee {
public:
    TrameEthernet() {
        entete = "ETH";
    }

    void encapsuler(std::shared_ptr<void> packet_ip) override {
        payload = packet_ip;
    }

    std::shared_ptr<void> decapsuler() override {
        return payload;
    }
};

class Byte : public Donnee {
public:
    Byte() {
        entete = "Byte";
    }

    void encapsuler(std::shared_ptr<void> trame_ethernet) override {
        payload = trame_ethernet;
    }

    std::shared_ptr<void> decapsuler() override {
        return payload;
    }
};

class Interface {
public:
    std::shared_ptr<Interface> cable;

    void envoyer(const std::string& string) {
        auto packet_ip = std::make_shared<PacketIP>();
        auto trame_ethernet = std::make_shared<TrameEthernet>();
        auto bytes = std::make_shared<Byte>();

        packet_ip->encapsuler(std::make_shared<std::string>(string));
        trame_ethernet->encapsuler(packet_ip);
        bytes->encapsuler(trame_ethernet);

        cable->recevoir(bytes);
    }

    void recevoir(std::shared_ptr<Byte> bytes) {
        auto trame = std::static_pointer_cast<TrameEthernet>(bytes->decapsuler());
        auto packet_ip = std::static_pointer_cast<PacketIP>(trame->decapsuler());
        auto string = std::static_pointer_cast<std::string>(packet_ip->decapsuler());
        std::cout << *string << std::endl;
    }
};

class Cable {
public:
    std::shared_ptr<Interface> entree;
    std::shared_ptr<Interface> sortie;

    void connect(const std::shared_ptr<Interface>& entree, const std::shared_ptr<Interface>& sortie) {
        this->entree = entree;
        this->sortie = sortie;
        entree->cable = this;
        sortie->cable = this;
    }
};

int main() {
    auto interface_in = std::make_shared<Interface>();
    auto interface_out = std::make_shared<Interface>();

    auto cable = std::make_shared<Cable>();
    cable->connect(interface_in, interface_out);

    interface_in->envoyer("Hello World!");

    return 0;
}

using System;

class Interface
{
    public Cable Cable { get; set; }

    public void Envoyer(string str)
    {
        PacketIP packetIp = new PacketIP();
        TrameEthernet trameEthernet = new TrameEthernet();
        Byte bytes = new Byte();

        packetIp.Encapsuler(str);
        trameEthernet.Encapsuler(packetIp);
        bytes.Encapsuler(trameEthernet);

        Cable.Sortie.Recevoir(bytes);
    }

    public void Recevoir(Byte bytes)
    {
        TrameEthernet trame = bytes.Decapsuler();
        PacketIP packetIp = trame.Decapsuler();
        string str = packetIp.Decapsuler();
        Console.WriteLine(str);
    }
}

class Cable
{
    public Interface Entree { get; set; }
    public Interface Sortie { get; set; }

    public void Connect(Interface entree, Interface sortie)
    {
        Entree = entree;
        Sortie = sortie;
        Entree.Cable = this;
        Sortie.Cable = this;
    }
}

abstract class Donnee
{
    public string Entete { get; set; }
    public object Payload { get; set; }
}

class PacketIP : Donnee
{
    public PacketIP()
    {
        Entete = "IP";
    }

    public void Encapsuler(string str)
    {
        Payload = str;
    }

    public string Decapsuler()
    {
        return (string)Payload;
    }
}

class TrameEthernet : Donnee
{
    public TrameEthernet()
    {
        Entete = "ETH";
    }

    public void Encapsuler(PacketIP packetIp)
    {
        Payload = packetIp;
    }

    public PacketIP Decapsuler()
    {
        return (PacketIP)Payload;
    }
}

class Byte : Donnee
{
    public Byte()
    {
        Entete = "Byte";
    }

    public void Encapsuler(TrameEthernet trameEthernet)
    {
        Payload = trameEthernet;
    }

    public TrameEthernet Decapsuler()
    {
        return (TrameEthernet)Payload;
    }
}

class Program
{
    static void Main()
    {
        Interface interfaceIn = new Interface();
        Interface interfaceOut = new Interface();

        Cable cable = new Cable();
        cable.Connect(interfaceIn, interfaceOut);

        interfaceIn.Envoyer("Hello World!");
    }
}

Exercice avancé sur l’héritage

Login with your site account

Register a new account