Exercice C# Corrigé – POO

// Importe l'espace de noms System pour utiliser
// Console et Math.PI.
using System;

// Déclare une classe appelée "Cercle".
class Cercle
{
    // Déclare une propriété publique "Rayon"
    // qui contient le rayon du cercle.
    public double Rayon;

    // Constructeur de la classe "Cercle".
    // Il reçoit le rayon en paramètre.
    public Cercle(double rayon)
    {
        // Initialise le rayon du cercle
        // avec la valeur reçue en paramètre.
        Rayon = rayon;
    }

    // Déclare une méthode qui calcule
    // et retourne la surface du cercle.
    public double GetArea()
    {
        // Formule de la surface :
        // Surface = π × rayon²
        return Rayon * Rayon * Math.PI;
    }

    // Déclare une méthode qui calcule
    // et retourne le périmètre du cercle.
    public double GetPerimeter()
    {
        // Formule du périmètre :
        // Périmètre = 2 × π × rayon
        return 2 * Rayon * Math.PI;
    }
}

// Déclare la classe principale du programme.
public class Program
{
    // Point d'entrée du programme.
    public static void Main()
    {
        // Crée un objet "c" de la classe Cercle
        // avec un rayon de 6.25.
        var c = new Cercle(6.25);

        // Calcule et affiche la surface du cercle.
        Console.WriteLine(c.GetArea());

        // Calcule et affiche le périmètre du cercle.
        Console.WriteLine(c.GetPerimeter());
    }
}

using System;

// Déclare la classe "Person".
// Cette classe sert de classe de base pour Student et Teacher.
class Person
{
    // Déclare l'attribut "age".
    // "protected" permet à la classe Person et à ses classes
    // dérivées d'accéder directement à cet attribut.
    protected int age;

    // Déclare une méthode qui affiche un message de bienvenue.
    public void sayHello()
    {
        Console.WriteLine("Hello");
    }

    // Déclare une méthode permet de définir l'âge du personne.
    public void SetAge(int n)
    {
        // Affecte la valeur reçue à l'attribut "age".
        age = n;
    }
}

// Déclare la classe "Student" qui hérite de la classe "Person".
class Student : Person
{
    // Méthode permettant d'indiquer que l'étudiant va en cours.
    public void GoToClasses()
    {
        Console.WriteLine("I’m going to class.");
    }

    // Méthode permettant d'afficher l'âge de l'étudiant.
    public void DisplayAge()
    {
        // Accède directement à "age" grâce au mot-clé "protected".
        Console.WriteLine("My age is: {0} years old", age);
    }
}

// Déclare la classe "Teacher" qui hérite de la classe "Person".
class Teacher : Person
{
    // Déclare un attribut privé "subject"
    // qui peut contenir la matière enseignée.
    private string subject;

    // Méthode permettant d'afficher un message d'explication.
    public void Explain()
    {
        Console.WriteLine("Explanation begins");
    }
}

// Déclare la classe de test.
class Test
{
    // Point d'entrée du programme.
    static void Main()
    {
        // Crée un objet "p" de type Person.
        Person p = new Person();

        // Appelle la méthode "sayHello()" de l'objet "p".
        p.sayHello();

        // Crée un objet "s" de type Student.
        Student s = new Student();

        // Appelle la méthode qui indique que l'étudiant va en cours.
        s.GoToClasses();

        // Définit l'âge de l'étudiant à 15 ans.
        s.SetAge(15);

        // Appelle la méthode "sayHello()" héritée de Person.
        s.sayHello();

        // Affiche l'âge de l'étudiant.
        s.DisplayAge();

        // Crée un objet "t" de type Teacher.
        Teacher t = new Teacher();

        // Définit l'âge de l'enseignant à 40 ans.
        t.SetAge(40);

        // Appelle la méthode "sayHello()" héritée de Person.
        t.sayHello();

        // Appelle la méthode "Explain()" de la classe Teacher.
        t.Explain();
    }
}

using System;

// Déclare la classe "Complex" qui représente un nombre complexe.
class Complex
{
    // "a" représente la partie réelle du nombre complexe.
    // "b" représente la partie imaginaire du nombre complexe.
    public double a, b;

    // Constructeur de la classe "Complex".
    // Il reçoit la partie réelle et la partie imaginaire.
    public Complex(double real, double imag)
    {
        // Initialise la partie réelle.
        a = real;

        // Initialise la partie imaginaire.
        b = imag;
    }

    // Retourne la partie réelle du nombre complexe.
    public double GetReal()
    {
        return a;
    }

    // Modifie la partie réelle du nombre complexe.
    public void SetReal(double a)
    {
        // "this.a" désigne l'attribut "a" de l'objet.
        // "a" désigne le paramètre de la méthode.
        this.a = a;
    }

    // Retourne la partie imaginaire du nombre complexe.
    public double GetImaginary()
    {
        return b;
    }

    // Modifie la partie imaginaire du nombre complexe.
    public void SetImaginary(double b)
    {
        // "this.b" désigne l'attribut "b" de l'objet.
        // "b" désigne le paramètre de la méthode.
        this.b = b;
    }

    // Retourne le nombre complexe sous forme de chaîne
    // de caractères. Exemple : (4,8)
    public new string ToString()
    {
        return "(" + a + "," + b + ")";
    }

    // Calcule et retourne le module du nombre complexe.
    // Formule : √(a² + b²)
    public double GetMagnitude()
    {
        return Math.Sqrt((a * a) + (b * b));
    }

    // Additionne un autre nombre complexe "c"
    // avec le nombre complexe courant.
    public void Sum(Complex c)
    {
        // Additionne les parties réelles.
        a += c.GetReal();

        // Additionne les parties imaginaires.
        b += c.GetImaginary();
    }
}

// Classe utilisée pour tester la classe Complex.
class Test
{
    // Point d'entrée du programme.
    static void Main()
    {
        // Crée un premier nombre complexe :
        // partie réelle = 4
        // partie imaginaire = 8
        Complex c1 = new Complex(4, 8);

        // Affiche le nombre complexe.
        Console.WriteLine("Le nombre est: " + c1.ToString());

        // Modifie la partie imaginaire de c1 et la remplace par 6.
        c1.SetImaginary(6);

        // Affiche le nombre complexe après la modification.
        Console.WriteLine("Le nombre est: " + c1.ToString());

        // Affiche un message avant le calcul du module.
        Console.Write("L'ordre de grandeur: ");

        // Calcule et affiche le module du nombre complexe.
        Console.WriteLine(c1.GetMagnitude());

        // Crée un deuxième nombre complexe :
        // partie réelle = -2
        // partie imaginaire = 3
        Complex c2 = new Complex(-2, 3);

        // Additionne c2 à c1.
        c1.Sum(c2);

        // Affiche un message avant d'afficher le résultat.
        Console.Write("Après l'addition: ");

        // Affiche le résultat de l'addition.
        Console.WriteLine(c1.ToString());
    }
}

using System;

// Déclare la classe "House" qui représente une maison.
class House
{
    // Stocke la surface de la maison en m².
    // "protected" permet aux classes dérivées d'y accéder.
    protected int surface;

    // Stocke la porte associée à la maison.
    protected Door door;

    // Constructeur de la classe "House".
    // Il reçoit la surface de la maison.
    public House(int surface)
    {
        // Initialise la surface de la maison.
        this.surface = surface;

        // Crée automatiquement une nouvelle porte pour la maison.
        door = new Door();
    }

    // Propriété permettant de lire et de modifier la surface.
    public int Surface
    {
        // Retourne la surface.
        get { return surface; }

        // Modifie la surface.
        set { surface = value; }
    }

    // Propriété permettant d'accéder à la porte de la maison.
    public Door Door
    {
        // Retourne la porte.
        get { return door; }

        // Modifie la porte.
        set { door = value; }
    }

    // Méthode virtuelle permet d'afficher les infos de la maison.
    // "virtual" permet aux classes dérivées de redéfinir cette 
    // méthode.
    public virtual void Display()
    {
        Console.WriteLine(
            "Je suis une maison, ma surface est de {0} m2.",
            surface
        );
    }
}

// Déclare la classe "Door" qui représente une porte.
class Door
{
    // Stocke la couleur de la porte.
    protected string color;

    // Constructeur par défaut.
    public Door()
    {
        // Définit la couleur par défaut à "blue".
        color = "blue";
    }

    // Constructeur permettant de choisir la couleur de la porte.
    public Door(string color)
    {
        // Initialise la couleur avec la valeur reçue.
        this.color = color;
    }

    // Propriété permettant de lire et de modifier la couleur.
    public string Color
    {
        // Retourne la couleur.
        get { return color; }

        // Modifie la couleur.
        set { color = value; }
    }

    // Affiche les informations concernant la porte.
    public void Display()
    {
        Console.WriteLine(
            "Je suis une porte, ma couleur est {0}.",
            color
        );
    }
}

// Déclare la classe "Apartment" qui hérite de "House".
class Apartment : House
{
    // Constructeur de la classe "Apartment".
    public Apartment() : base(50)
    {
        // Appelle le constructeur de House
        // avec une surface de 50 m².
    }

    // Redéfinit la méthode Display() de la classe House.
    // "override" permet de fournir un comportement spécifique
    // pour un appartement.
    public override void Display()
    {
        // Affiche les informations spécifiques à l'appartement.
        Console.WriteLine(
            "Je suis un appartement, ma surface est "+surface+" m2"
        );
    }
}

// Déclare la classe "Person" qui représente une personne.
class Person
{
    // Stocke le nom de la personne.
    protected string name;

    // Stocke la maison associée à la personne.
    protected House house;

    // Constructeur par défaut.
    public Person()
    {
        // Définit le nom par défaut.
        name = "Thomas";

        // Crée une maison de 150 m².
        house = new House(150);
    }

    // Constructeur permettant de définir le nom et la maison.
    public Person(string name, House house)
    {
        // Initialise le nom.
        this.name = name;

        // Initialise la maison.
        this.house = house;
    }

    // Propriété permettant de lire et de modifier le nom.
    public string Name
    {
        // Retourne le nom.
        get { return name; }

        // Modifie le nom.
        set { name = value; }
    }

    // Propriété permettant de lire et de modifier la maison.
    public House House
    {
        // Retourne la maison.
        get { return house; }

        // Modifie la maison.
        set { house = value; }
    }

    // Affiche les informations de la personne,
    // de sa maison et de sa porte.
    public void Display()
    {
        // Affiche le nom de la personne.
        Console.WriteLine("Je m'appele {0}.", name);

        // Affiche les informations de la maison.
        house.Display();

        // Accède à la porte de la maison
        // puis affiche ses informations.
        house.Door.Display();
    }
}

// Classe utilisée pour tester le programme.
class Test
{
    // Point d'entrée du programme.
    static void Main()
    {
        // Crée un appartement de 50 m².
        Apartment MyApartament = new Apartment();

        // Crée une personne avec les valeurs par défaut.
        Person person = new Person();

        // Modifie le nom de la personne.
        person.Name = "Thomas";

        // Associe l'appartement à la personne.
        person.House = MyApartament;

        // Affiche les informations de la personne,
        // de son appartement et de sa porte.
        person.Display();
    }
}