Aller au contenu principal

Introduction à la POO

Notions théoriques​

Pourquoi la POO ?​

La programmation orientée objet (POO) organise le code autour d'objets qui représentent des entités du monde réel. Chaque objet regroupe des données (ce qu'il est) et des comportements (ce qu'il fait).

// Approche procédurale — données éparpillées, difficile à maintenir
string nom1 = "Alice";
int age1 = 20;
double note1 = 15.5;

string nom2 = "Bob";
int age2 = 21;
double note2 = 12.0;

// Approche POO — données et comportements regroupés dans un objet
class Etudiant
{
    public string Nom  { get; set; } = "";
    public int    Age  { get; set; }
    public double Note { get; set; }

    public string ObtenirMention() => Note >= 10 ? "Admis" : "Refusé";
}

var alice = new Etudiant { Nom = "Alice", Age = 20, Note = 15.5 };
var bob   = new Etudiant { Nom = "Bob",   Age = 21, Note = 12.0 };
Console.WriteLine(alice.ObtenirMention());   // "Admis"

Classe vs objet​

  • Une classe est un modèle (le plan d'un bâtiment, le moule d'une pièce)
  • Un objet est une instance de la classe (le bâtiment construit depuis le plan)
// Classe = le modèle
class Voiture
{
    public string Marque { get; set; } = "";
    public int    Annee  { get; set; }

    public void Demarrer() => Console.WriteLine($"{Marque} démarre.");
}

// Objets = des instances de ce modèle
var v1 = new Voiture { Marque = "Peugeot", Annee = 2022 };
var v2 = new Voiture { Marque = "Renault", Annee = 2020 };

v1.Demarrer();   // "Peugeot démarre."
v2.Demarrer();   // "Renault démarre."

Le mot-clé new​

new crée une instance de la classe en mémoire et appelle le constructeur (méthode d'initialisation).

var etudiant = new Etudiant();      // crée un objet Etudiant en mémoire

null — l'absence d'objet​

null signifie qu'une variable de type classe ne pointe vers aucun objet en mémoire.

Etudiant? e = null;         // e ne pointe vers aucun objet
Console.WriteLine(e?.Nom);  // null (sans exception grâce à ?.)

e = new Etudiant { Nom = "Alice", Note = 15.5 };
Console.WriteLine(e?.Nom);  // "Alice"
NullReferenceException — l'erreur la plus fréquente

Accéder à un membre d'un objet null provoque une NullReferenceException :

Etudiant? e = null;
Console.WriteLine(e.Nom);   // CRASH : NullReferenceException
Console.WriteLine(e?.Nom);  // OK : retourne null, pas d'exception

L'opérateur ?. (null-conditionnel) protège l'accès : si e est null, l'expression retourne null au lieu de planter.

Les 4 grands concepts de la POO​

ConceptDéfinition courte
EncapsulationRegrouper données et méthodes, cacher les détails internes
HéritageUne classe réutilise et étend une autre classe
AbstractionDéfinir une interface sans imposer l'implémentation
PolymorphismeTraiter différents types d'objets de façon uniforme

Ces 4 concepts seront développés tout au long du cours.

Exemple pratique​

// Modélisation d'un système scolaire minimal
class Personne
{
    public string Prenom { get; set; } = "";
    public string Nom    { get; set; } = "";

    public string NomComplet => $"{Prenom} {Nom}";
    public virtual void SePresenter() =>
        Console.WriteLine($"Je suis {NomComplet}.");
}

class Etudiant : Personne
{
    public double Note { get; set; }

    public override void SePresenter() =>
        Console.WriteLine($"Je suis l'étudiant {NomComplet}, ma note est {Note:F1}/20.");
}

class Professeur : Personne
{
    public string Matiere { get; set; } = "";

    public override void SePresenter() =>
        Console.WriteLine($"Je suis le professeur {NomComplet}, j'enseigne {Matiere}.");
}

// Création d'objets
var prof   = new Professeur { Prenom = "Jean", Nom = "Dupont", Matiere = "Informatique" };
var alice  = new Etudiant   { Prenom = "Alice", Nom = "Martin", Note = 15.5 };
var bob    = new Etudiant   { Prenom = "Bob",   Nom = "Durand", Note = 9.0  };

// Polymorphisme : on traite tous les objets comme des Personne
Personne[] personnes = [prof, alice, bob];
foreach (Personne p in personnes)
    p.SePresenter();   // chacun utilise sa propre version de SePresenter()

Test de mémorisation/compréhension​


Quelle est la différence entre une classe et un objet ?


Que se passe-t-il si on accède à un membre d'un objet `null` sans opérateur `?.` ?


Quel mot-clé crée un nouvel objet en mémoire ?


Lequel des 4 concepts POO décrit la capacité de traiter différents types d'objets de façon uniforme ?


À quoi sert l'opérateur `?.` (null-conditionnel) ?


TP pour réfléchir et résoudre des problèmes​

Vous allez créer un carnet d'adresses simple avec des objets.

Étape 1 — Définir la classe Contact​

Définissez une classe Contact avec des propriétés et une méthode d'affichage.


Bonne pratique - Regrouper les données liées dans une classe

Plutôt que d'avoir des variables séparées string prenom1, string nom1, string email1, string prenom2..., regroupez les données cohérentes dans une classe. Le code devient plus lisible, plus facile à maintenir et on peut créer autant d'instances que nécessaire.

Étape 2 — Créer et stocker des contacts​

Instanciez plusieurs contacts et stockez-les dans une liste.


Bonne pratique - Syntaxe d'initialisation par objet

La syntaxe new Contact { Prenom = "Alice", ... } s'appelle initialiseur d'objet. Elle est disponible depuis C# 3 et permet d'initialiser les propriétés sans avoir à écrire un constructeur avec paramètres pour chaque cas. C'est idiomatique en C# pour les objets de données simples.

Étape 3 — Rechercher dans les contacts​

Parcourez la liste et affichez les contacts dont le nom contient une chaîne.


Bonne pratique - StringComparison.OrdinalIgnoreCase pour la recherche

StringComparison.OrdinalIgnoreCase rend la recherche insensible à la casse : "Martin" et "martin" donnent tous deux un résultat positif. Sans ce paramètre, Contains est sensible à la casse par défaut.

📌 Une solution