Module C#.9 – Programmation Orientée Objet

Objectif

Maîtriser la POO complète en C# : classes, propriétés, encapsulation, héritage, interfaces, polymorphisme et abstraction pour créer des architectures modulaires et maintenables.

Théorie

Classes

Définition

public class Personne
{
    // Propriétés (champs)
    public string Nom { get; set; }
    public int Age { get; set; }
    
    // Constructeur
    public Personne(string nom, int age)
    {
        Nom = nom;
        Age = age;
    }
    
    // Méthodes
    public void Afficher()
    {
        Console.WriteLine($"{Nom} a {Age} ans");
    }
}

Création d'objets

Personne jean = new Personne("Jean", 30);
jean.Afficher();

Propriétés

Auto-propriétés

public class Personne
{
    public string Nom { get; set; }
    public int Age { get; set; }
}

Propriétés avec logique

private int age;

public int Age
{
    get { return age; }
    set
    {
        if (value > 0 && value < 150)
        {
            age = value;
        }
        else
        {
            throw new ArgumentException("Age invalide");
        }
    }
}

Propriétés en lecture seule

public string NomComplet { get; private set; }

// Ou calculée
public string NomComplet => $"{Prenom} {Nom}";

Propriétés avec initialisation

public List<string> Hobbies { get; set; } = new List<string>();

Encapsulation

Visibilité

public class Personne
{
    public string Nom;        // Accessible partout
    private int age;          // Accessible seulement dans la classe
    protected string ville;   // Accessible dans classe et enfants
    internal string email;    // Accessible dans le même assembly
}

Getters et Setters

private int _age;

public int GetAge()
{
    return _age;
}

public void SetAge(int value)
{
    if (value > 0)
    {
        _age = value;
    }
}

// Préférer les propriétés
public int Age
{
    get => _age;
    set => _age = value > 0 ? value : _age;
}

Constructeurs

Constructeur par défaut

Si aucun constructeur n'est défini, C# en crée un par défaut.

public class Personne
{
    public string Nom { get; set; }
    // Constructeur par défaut implicite
}

Personne p = new Personne();  // OK

Constructeurs multiples

public class Personne
{
    public string Nom { get; set; }
    public int Age { get; set; }
    
    public Personne(string nom)
    {
        Nom = nom;
        Age = 0;
    }
    
    public Personne(string nom, int age)
    {
        Nom = nom;
        Age = age;
    }
}

this

Référence à l'instance actuelle.

public Personne(string nom, int age)
{
    this.Nom = nom;      // this.Nom = propriété de l'instance
    this.Age = age;      // nom = paramètre
}

Héritage

Une classe peut hériter d'une autre classe.

Syntaxe

class Etudiant : Personne
{
    public string Ecole { get; set; }
    
    public Etudiant(string nom, int age, string ecole) 
        : base(nom, age)
    {
        Ecole = ecole;
    }
    
    public override void Afficher()
    {
        base.Afficher();  // Appelle la méthode parente
        Console.WriteLine($"École : {Ecole}");
    }
}

base

Référence à la classe parente.

public Etudiant(string nom, int age, string ecole) 
    : base(nom, age)  // Appelle le constructeur parent
{
    Ecole = ecole;
}

virtual et override

virtual : Permet la surcharge dans les classes enfants

public class Personne
{
    public virtual void Afficher()
    {
        Console.WriteLine("Personne");
    }
}

override : Redéfinit une méthode parente

public class Etudiant : Personne
{
    public override void Afficher()
    {
        base.Afficher();
        Console.WriteLine("Étudiant");
    }
}

Interfaces

Contrat que les classes doivent respecter.

Définition

interface IAffichable
{
    void Afficher();
}

Implémentation

class Personne : IAffichable
{
    public void Afficher()
    {
        Console.WriteLine("Personne");
    }
}

Plusieurs interfaces

interface IAffichable
{
    void Afficher();
}

interface ISauvegardable
{
    void Sauvegarder();
}

class Personne : IAffichable, ISauvegardable
{
    public void Afficher() { }
    public void Sauvegarder() { }
}

Abstraction

Classes abstraites

Ne peut pas être instanciée, sert de base.

abstract class Animal
{
    protected string nom;
    
    public Animal(string nom)
    {
        this.nom = nom;
    }
    
    // Méthode concrète
    public void Dormir()
    {
        Console.WriteLine($"{nom} dort");
    }
    
    // Méthode abstraite (doit être implémentée)
    public abstract void FaireDuBruit();
}

class Chien : Animal
{
    public Chien(string nom) : base(nom) { }
    
    public override void FaireDuBruit()
    {
        Console.WriteLine("Wouf !");
    }
}

Polymorphisme

Traiter différents types de manière uniforme.

Animal[] animaux = {
    new Chien("Rex"),
    new Chat("Mimi")
};

foreach (Animal animal in animaux)
{
    animal.FaireDuBruit();  // Polymorphisme
}

Liaison dynamique : La méthode appelée dépend du type réel de l'objet, pas du type de la variable.

Exercice

1. Classes

   • Créez des classes avec constructeurs
   • Testez l'encapsulation
   • Utilisez propriétés avec logique

2. Héritage

   • Créez une hiérarchie de classes
   • Testez base et override
   • Comprenez le polymorphisme

3. Interfaces

   • Créez des interfaces
   • Implémentez-les dans des classes
   • Testez l'implémentation multiple

4. Abstraction

   • Créez des classes abstraites
   • Implémentez les méthodes abstraites
   • Comparez avec interfaces

5. Polymorphisme

   • Utilisez le polymorphisme
   • Testez la liaison dynamique
   • Créez des collections polymorphiques

Quiz

1. Que fait base() ?

   • Crée un objet de base
   • Appelle le constructeur parent
   • Appelle une méthode parente

2. Quelle est la différence entre interface et classe abstraite ?

   • Aucune différence
   • Interface : implémentation multiple, classe abstraite : héritage simple
   • Classe abstraite est plus rapide

3. Que signifie override ?

   • Crée une nouvelle méthode
   • Redéfinit une méthode parente (virtual)
   • Supprime la méthode parente

4. Qu'est-ce que le polymorphisme ?

   • Plusieurs formes d'un objet
   • Traiter différents types uniformément
   • Créer plusieurs objets

5. Que fait private ?

   • Rend la classe privée
   • Rend le champ/méthode accessible seulement dans la classe
   • Empêche l'héritage

Mini défi

Mission : Créer un système POO complet

Créez un système de gestion de bibliothèque :

Structure :

1. Interface IEmpruntable (Emprunter, Retourner, EstDisponible)
2. Classe abstraite Document (Titre, Auteur)
3. Classe Livre (hérite Document, implémente IEmpruntable)
4. Classe DVD (hérite Document, implémente IEmpruntable)
5. Classe Bibliotheque (gère collection de Documents)

Critères :

• ✅ POO complète (héritage, interfaces, abstraction)
• ✅ Encapsulation appropriée
• ✅ Polymorphisme utilisé
• ✅ Code bien structuré

Objectif : Maîtriser la POO complète C# et créer une architecture propre.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez classes, héritage, interfaces, abstraction et polymorphisme.