Accueil › Les fondations › Chapitre 4

La programmation objet

On te dira qu'il y a « quatre piliers ». C'est vrai, mais ça n'aide personne. Voici plutôt le problème que la POO résout, puis les quatre outils qu'elle propose — dans l'ordre où ils deviennent utiles.

Le problème que ça résout

Imaginons un programme qui gère des commandes, écrit « à plat » : des variables d'un côté, des fonctions de l'autre.

// des données nues, sans protection
decimal total = 0;
string statut = "brouillon";
List<string> lignes = [];

void Ajouter(string l) { lignes.Add(l); }
void Valider() { statut = "valide"; }

// ...400 lignes plus loin, ailleurs dans le programme :
statut = "vlaide";      // faute de frappe, personne ne bronche
total  = -50;           // total négatif accepté
lignes.Clear();         // commande vidée après validation

public class Commande
{
    private readonly List<string> _lignes = [];
    public Statut Statut { get; private set; } = Statut.Brouillon;
    public decimal Total => _lignes.Count * 10m;
    public IReadOnlyList<string> Lignes => _lignes;

    public void Ajouter(string ligne)
    {
        if (Statut != Statut.Brouillon)
            throw new InvalidOperationException("Commande déjà validée");
        _lignes.Add(ligne);
    }

    public void Valider()
    {
        if (_lignes.Count == 0)
            throw new InvalidOperationException("Commande vide");
        Statut = Statut.Validee;
    }
}

Pilier 1 — Encapsulation : cacher pour protéger

Encapsuler = rendre l'intérieur inaccessible, et n'exposer que des opérations qui laissent l'objet dans un état correct.

Pilier 2 — Héritage : « est un »

L'héritage permet à une classe de reprendre tout ce qu'une autre possède, puis d'ajouter ou de modifier.

public class Animal
{
    public string Nom { get; init; } = "";
    public virtual string Crier() => "…";       // virtual = les filles PEUVENT redéfinir
    public void Dormir() => Console.WriteLine($"{Nom} dort");   // commun, non redéfinissable
}

public class Chien : Animal                     // « Chien EST UN Animal »
{
    public override string Crier() => "Wouf";   // override = je redéfinis
}

public class Chat : Animal
{
    public override string Crier() => "Miaou";
    public void Ronronner() => Console.WriteLine("prrr");   // propre au chat
}

var c = new Chien { Nom = "Rex" };
c.Dormir();                        // hérité tel quel
Console.WriteLine(c.Crier());      // Wouf
Animal a = c;                      // ✅ un Chien peut être vu comme un Animal
// c.Ronronner();                  // ❌ un Chien n'a pas cette méthode

public class Base    { public virtual string Dire() => "base"; }
public class Fille   { }   // ...
public class Mauvais : Base { public new string Dire() => "fille"; }   // masque, ne redéfinit pas

Base x = new Mauvais();
Console.WriteLine(x.Dire());   // "base" 😱 — pas ce que tu voulais

Pilier 3 — Polymorphisme : un ordre, plusieurs comportements

C'est le pilier qui change vraiment la façon d'écrire du code. Sans lui, tu testes le type. Avec lui, tu demandes.

foreach (var a in animaux)
{
    if (a is Chien)      Console.WriteLine("Wouf");
    else if (a is Chat)  Console.WriteLine("Miaou");
    else if (a is Vache) Console.WriteLine("Meuh");
    // ← chaque nouvel animal impose de
    //   retrouver et modifier ce bloc,
    //   et tous ses jumeaux ailleurs.
}

foreach (var a in animaux)
    Console.WriteLine(a.Crier());

// Ajouter une Vache : une nouvelle classe,
// et RIEN à modifier ici.
// (C'est le « O » de SOLID : ouvert à
//  l'extension, fermé à la modification.)

Pilier 4 — Abstraction

L'abstraction consiste à décrire ce qu'on peut faire sans dire comment c'est fait. C'est le sujet du chapitre suivant, qui lui est entièrement consacré — c'est le concept le plus rentable de tout C#.

Composition > héritage (la leçon la plus utile du chapitre)

L'héritage est séduisant et piège les débutants. Il crée le couplage le plus fort qui existe : la fille dépend de tout le parent, y compris de ses détails internes futurs.

// « une commande, c'est comme une liste »
public class Commande : List<Ligne>
{
    public decimal Total => this.Sum(l => l.Prix);
}

var c = new Commande();
c.Clear();       // 😱 hérité de List : vide la commande
c.Insert(0, l);  // 😱 contourne toutes tes règles
// Impossible d'empêcher : tu as tout ouvert.

// « une commande CONTIENT des lignes »
public class Commande
{
    private readonly List<Ligne> _lignes = [];
    public IReadOnlyList<Ligne> Lignes => _lignes;
    public decimal Total => _lignes.Sum(l => l.Prix);

    public void Ajouter(Ligne l) { /* règles ici */ }
}
// Tu contrôles exactement la surface exposée.

Tout hérite d'object

Chaque type en .NET descend de object et possède donc quatre membres, qu'il est utile de connaître :

public class Produit
{
    public string Nom { get; init; } = "";
    public decimal Prix { get; init; }

    // Affichage lisible dans les logs et le débogueur — très rentable
    public override string ToString() => $"{Nom} ({Prix:C})";
}

var p = new Produit { Nom = "Clé USB", Prix = 12.5m };
Console.WriteLine(p);              // Clé USB (12,50 €)   ← ToString() appelé implicitement
Console.WriteLine(p.GetType().Name);   // Produit
Console.WriteLine(p.Equals(p));        // True
Console.WriteLine(p.GetHashCode());    // un entier

Un record fournit ToString, Equals et GetHashCode corrects gratuitement (chapitre 10).

SOLID, en français et sans dogme

Vérifie que c'est passé

Fiches de révision