Classe et objet : la POO expliquée

La programmation orientée objet (POO) est une façon d'organiser un programme en objets qui regroupent des données et les traitements qui s'y appliquent. Une classe est le plan qui décrit ces objets ; un objet est un exemplaire concret, fabriqué à partir de ce plan. Ce chapitre explique pourquoi on programme ainsi, puis comment écrire une classe en C#, créer des objets et comprendre ce qu'est une référence.

Pourquoi la programmation orientée objet

Imagine le suivi des tickets d'assistance de Sorbier Logistique écrit sans objets. Pour trois tickets, tu déclares trois séries de variables :

string titre1 = "Écran noir";        int duree1 = 45;   string statut1 = "en_cours";
string titre2 = "Imprimante bloquée"; int duree2 = 20;  string statut2 = "resolu";
string titre3 = "Odoo lent";          int duree3 = 60;  string statut3 = "en_cours";

Avec 200 tickets, c'est intenable. Des tableaux parallèles (titres[i], durees[i], statuts[i]) font un peu mieux, jusqu'au jour où un tri déplace les titres sans déplacer les durées. Et rien n'empêche une fonction quelconque d'écrire statut2 = "n'importe quoi" : les règles de gestion sont dispersées dans tout le programme.

La POO part d'une idée simple : ce qui va ensemble reste ensemble. Un ticket a un titre, une durée, un statut (ses données) et sait faire certaines choses : passer en cours, cumuler du temps, dire s'il est urgent (son comportement). On écrit une fois la description d'un ticket, et le programme manipule ensuite des objets tickets, chacun avec ses propres valeurs.

Un objet a trois caractéristiques :

Classe et objet : le plan et les exemplaires

Une classe décrit un type d'objets : quelles données ils portent, quelles méthodes ils offrent. Elle ne contient aucune valeur particulière. Un objet, ou instance, est un exemplaire créé à partir de la classe, avec ses propres valeurs. Créer un objet s'appelle instancier la classe.

L'image classique est celle du plan d'architecte : le plan (la classe) décrit une maison ; on construit autant de maisons (les objets) qu'on veut, chacune avec sa couleur de volets. Repeindre une maison ne change ni le plan ni les autres maisons.

Écrire une classe en C#

Dans le projet GestParc.Console, crée un fichier Ticket.cs (dans Visual Studio : clic droit sur le projet, Ajouter → Classe). Une classe par fichier, et le fichier porte le nom de la classe : c'est la convention de tous les projets C#.

namespace GestParc.Console;

class Ticket
{
    // Champs : l'état de chaque ticket
    public int Numero;
    public string Titre = "";
    public string Priorite = "normale";
    public string Statut = "ouvert";
    public int DureeTotaleMin;

    // Méthodes : le comportement
    public void Prendre()
    {
        Statut = "en_cours";
    }

    public void AjouterTemps(int minutes)
    {
        DureeTotaleMin += minutes;
    }

    public bool EstUrgent()
    {
        return Priorite == "haute" || Priorite == "critique";
    }

    public void Afficher()
    {
        Console.WriteLine($"#{Numero} {Titre} [{Priorite}, {Statut}] {DureeTotaleMin} min");
    }
}

Lis-la ligne par ligne :

• namespace GestParc.Console; range la classe dans un espace de noms, l'équivalent d'un dossier logique. Deux classes Ticket peuvent coexister dans deux espaces de noms différents.
• class Ticket déclare la classe. Son nom est un nom commun au singulier, en PascalCase.
• Les champs (Numero, Titre…) sont les variables de l'objet : chaque ticket aura les siens. Un champ peut avoir une valeur initiale (= "normale").
• Les méthodes (Prendre, AjouterTemps…) agissent sur les champs de l'objet. Prendre() ne reçoit aucun paramètre : elle sait sur quel ticket elle travaille.
• public rend le membre accessible depuis l'extérieur de la classe. Ces champs publics sont une facilité de départ : le chapitre 3 les remplacera par des propriétés protégées.

Les champs et les méthodes sont les membres de la classe. Les sujets d'examen parlent souvent d'attributs pour les champs : c'est le vocabulaire d'UML. En C#, le mot « attribut » désigne aussi autre chose (les annotations entre crochets, vues au chapitre 14) ; ce cours dit « champ » pour éviter la confusion.

Créer des objets avec new

L'opérateur new fabrique un objet et renvoie de quoi l'atteindre. On accède ensuite à ses membres avec un point.

Ticket t1 = new Ticket();
t1.Numero = 1;
t1.Titre = "Écran noir au démarrage";
t1.Priorite = "haute";

Ticket t2 = new Ticket();
t2.Numero = 2;
t2.Titre = "Bourrage papier, imprimante du 2e étage";

t1.Afficher();
t2.Afficher();
t1.Prendre();
t1.AjouterTemps(30);
t1.AjouterTemps(45);
t1.Afficher();
Console.WriteLine(t1.EstUrgent());
Console.WriteLine(t2.EstUrgent());

#1 Écran noir au démarrage [haute, ouvert] 0 min
#2 Bourrage papier, imprimante du 2e étage [normale, ouvert] 0 min
#1 Écran noir au démarrage [haute, en_cours] 75 min
True
False

t1.Prendre() a modifié le statut de t1 seulement : t2 est resté ouvert. C'est le cœur de la POO, chaque objet a son propre état. La notation t1.AjouterTemps(30) se lit « demande à t1 d'ajouter 30 minutes » : en POO, on dit qu'on envoie un message à l'objet.

Écrire new Ticket() puis remplir les champs un par un est fastidieux et dangereux : on peut oublier le titre. Le chapitre 4 règle ce problème avec les constructeurs. Depuis C# 9, tu peux aussi écrire Ticket t = new(); quand le type est déjà écrit à gauche.

Le mot-clé this

Dans une méthode, this désigne l'objet sur lequel la méthode est appelée. Quand tu écris Statut = "en_cours"; dans Prendre(), C# comprend this.Statut. On écrit this explicitement dans deux cas. Le premier exemple suppose un champ privé titre, écrit en camelCase (le chapitre 3 explique pourquoi les champs sont privés) :

private string titre = "";

public void Renommer(string titre)
{
    this.titre = titre;   // this.titre : le champ ; titre : le paramètre qui porte le même nom
}

public void AffecterA(Technicien technicien)
{
    technicien.Prendre(this);   // l'objet se passe lui-même en paramètre
}

Le premier cas est fréquent dans les constructeurs ; nommer le paramètre autrement (nouveauTitre) évite d'en avoir besoin. Le second sert à relier deux objets, comme au chapitre 5.

Un objet est une référence

Une variable de type classe ne contient pas l'objet : elle contient une référence vers lui, c'est-à-dire l'adresse où il se trouve en mémoire (le tas, heap). Copier la variable copie l'adresse, pas l'objet.

Ticket t3 = t1;                         // t3 et t1 désignent le MÊME objet
t3.Titre = "Écran noir (câble HDMI)";
Console.WriteLine(t1.Titre);
Console.WriteLine(t1 == t3);            // même référence ?

Ticket t4 = new Ticket();               // un autre objet, même contenu
t4.Numero = 1;
t4.Titre = "Écran noir (câble HDMI)";
Console.WriteLine(t1 == t4);

Écran noir (câble HDMI)
True
False

Les types simples (int, decimal, bool, DateOnly…) sont des types valeur : la variable contient directement la valeur, et la copier crée une copie indépendante.

int a = 10;
int b = a;
b = 20;
Console.WriteLine($"a = {a}, b = {b}");   // a = 10, b = 20

Une variable référence peut ne désigner aucun objet : elle vaut null. Appeler une méthode dessus lève une NullReferenceException, l'erreur d'exécution la plus fréquente en POO.

Ticket? t5 = null;
Console.WriteLine(t5?.Titre ?? "aucun ticket");   // aucun ticket
// t5.Afficher();   // NullReferenceException à l'exécution

Valeurs par défaut des champs

Un champ que personne n'a initialisé prend la valeur par défaut de son type : 0 pour les nombres, false pour un bool, null pour une référence, le 1er janvier de l'an 1 pour une date.

Ticket vide = new Ticket();
Console.WriteLine($"[{vide.Numero}] [{vide.Titre}] [{vide.DureeTotaleMin}] [{vide.Statut}]");
// [0] [] [0] [ouvert]

Titre affiche une chaîne vide parce que la classe l'initialise à "" ; sans cette initialisation, le champ vaudrait null et le compilateur avertirait (CS8618) qu'un string non nullable risque de rester nul. Un ticket numéro 0 sans titre n'a pourtant aucun sens : c'est le constructeur qui l'empêchera.

Organiser le projet : fichiers et espaces de noms

Dès que tu as plusieurs classes, range-les :

GestParc.Console/
├── GestParc.Console.csproj
├── Program.cs            le point d'entrée : crée les objets et les fait travailler
├── Ticket.cs             namespace GestParc.Console;
├── Logiciel.cs
└── Poste.cs

• Un fichier par classe, au nom de la classe.
• Chaque fichier commence par namespace NomDuProjet; (la forme sans accolades, valable pour tout le fichier).
• Pour utiliser une classe d'un autre espace de noms, ajoute using GestParc.Domaine; en tête du fichier.
• Quand le projet grossit, sépare la logique métier dans une bibliothèque de classes (dotnet new classlib -n GestParc.Domaine) que l'application console, puis l'application WinForms, référencent. Le chapitre 15 montre cette organisation complète.

Les quatre piliers de la POO

Tout le reste du cours développe quatre principes, que les sujets et les jurys appellent les piliers de la programmation objet.

Trouver les classes dans un énoncé

Avant d'écrire du code, il faut décider quelles classes créer. Une méthode simple, à appliquer sur un texte qui décrit le besoin :

1. Souligne les noms communs : ce sont des candidats classes ou champs. « Un technicien réalise des interventions sur un ticket ; chaque intervention a une durée et un compte rendu. »
2. Garde comme classe ce qui a plusieurs données et une vie propre (technicien, ticket, intervention) ; garde comme champ ce qui n'est qu'une valeur (durée, compte rendu).
3. Repère les verbes : ce sont des candidats méthodes, rangés dans la classe qui possède les données nécessaires. « Clôturer un ticket » devient Ticket.Resoudre().
4. Repère les liens entre classes (« un ticket a plusieurs interventions ») : ce sont les associations du chapitre 5.

Le résultat se dessine sous forme de diagramme de classes UML, que le cours UML détaille (diagramme de classes).

Exercices

class Logiciel
{
    public string Nom = "";
    public int NbLicences;
    public int NbInstallations;

    public int LicencesDisponibles()
    {
        return NbLicences - NbInstallations;
    }

    public bool PeutInstaller()
    {
        return LicencesDisponibles() > 0;
    }

    public void Installer()
    {
        NbInstallations++;
    }
}

Logiciel office = new Logiciel();
office.Nom = "Microsoft 365";
office.NbLicences = 10;
office.Installer();
office.Installer();
Console.WriteLine(office.LicencesDisponibles());   // 8

Ticket a = new Ticket();
a.Titre = "Souris HS";
Ticket b = a;
Ticket c = new Ticket();
c.Titre = "Souris HS";
b.AjouterTemps(10);
c.AjouterTemps(5);
a.AjouterTemps(20);
Console.WriteLine($"{a.DureeTotaleMin} {b.DureeTotaleMin} {c.DureeTotaleMin}");
Console.WriteLine(a == b);
Console.WriteLine(a == c);
b = c;
b.Titre = "Clavier HS";
Console.WriteLine($"{a.Titre} / {c.Titre}");

30 30 5
True
False
Souris HS / Clavier HS