Université de Gafsa

Institut Supérieur d'Administration des Entreprises de Gafsa

Framework .NET (C#)

Chapitre 3 : Classes, Objets, Polymorphisme et Surcharge

Enseignant : Boubaker KHMILI

Public : 2^ème année Licence Business Computing

Année universitaire 2026/2027

Objectifs du chapitre

À l'issue de ce chapitre, l'étudiant sera capable de :

Définir une classe avec ses attributs et ses méthodes
Instancier des objets et manipuler leurs membres
Appliquer l'encapsulation à l'aide des propriétés
Définir et utiliser des constructeurs (y compris la surcharge)
Mettre en œuvre l'héritage entre classes
Comprendre et appliquer le polymorphisme (virtual / override)
Surcharger des méthodes (method overloading)
Surcharger des opérateurs (operator)

Plan du chapitre

Classes et objets — Déclaration et instanciation
Encapsulation et propriétés
Constructeurs
Héritage
Polymorphisme
Surcharge de méthodes (Method Overloading)
Surcharge des opérateurs (Operator Overloading)

1

Classes et objets

1. Classes et objets

1.1 Concept fondamental

Une classe est un modèle (plan) qui définit la structure et le comportement d'un type d'objet. Un objet est une instance concrète de cette classe.

La programmation orientée objet (POO) repose sur quatre piliers :

Encapsulation : regrouper données et traitements, contrôler l'accès
Héritage : créer de nouvelles classes à partir de classes existantes
Polymorphisme : un même appel, des comportements différents
Abstraction : exposer l'essentiel, masquer la complexité

Analogie : La classe Voiture est le plan de fabrication. Chaque voiture produite (ma voiture, ta voiture) est un objet (instance).

1. Classes et objets

1.2 Déclaration d'une classe

class Etudiant
{
    // Attributs (champs)
    public string Nom;
    public int Age;
    public double Moyenne;

    // Méthode
    public void Afficher()
    {
        Console.WriteLine($"{Nom}, {Age} ans, moyenne : {Moyenne}");
    }

    public bool EstAdmis()
    {
        return Moyenne >= 10;
    }
}

Modificateurs d'accès

Modificateur	Visibilité
`public`	Accessible partout
`private`	Accessible uniquement dans la classe (par défaut)
`protected`	Accessible dans la classe et ses classes dérivées

1. Classes et objets

1.3 Instanciation et utilisation

// Création d'un objet (instanciation)
Etudiant e1 = new Etudiant();
e1.Nom = "Ali";
e1.Age = 21;
e1.Moyenne = 14.5;

// Utilisation des méthodes
e1.Afficher();            // Ali, 21 ans, moyenne : 14.5
Console.WriteLine(e1.EstAdmis());  // True

// Deuxième objet, même classe
Etudiant e2 = new Etudiant();
e2.Nom = "Sara";
e2.Age = 20;
e2.Moyenne = 8.0;
Console.WriteLine(e2.EstAdmis());  // False

Important : chaque objet possède sa propre copie des attributs. Modifier e1.Nom n'affecte pas e2.Nom.

1. Classes et objets

Exercice d'application

Exercice 1.1 — Classe Produit

Écrivez un programme qui :

Définit une classe Produit avec les attributs : Nom (string), Prix (double), Quantite (int)
Ajoute une méthode ValeurStock() qui retourne Prix * Quantite
Ajoute une méthode Afficher() qui affiche les détails du produit
Crée deux produits, affiche leurs détails et la valeur de leur stock

Exercice 1.2 — Traçage

class Compteur
{
    public int Valeur;
    public void Incrementer() { Valeur++; }
}
// ---
Compteur a = new Compteur();
Compteur b = new Compteur();
a.Incrementer(); a.Incrementer(); a.Incrementer();
b.Incrementer();
Console.WriteLine($"{a.Valeur} {b.Valeur}");

1. Classes et objets

Correction — Exercice 1.1

✓ Correction

class Produit
{
    public string Nom;
    public double Prix;
    public int Quantite;

    public double ValeurStock()
    {
        return Prix * Quantite;
    }

    public void Afficher()
    {
        Console.WriteLine($"{Nom} — {Prix} DT x {Quantite} = {ValeurStock()} DT");
    }
}
// ---
Produit p1 = new Produit();
p1.Nom = "Cahier"; p1.Prix = 3.5; p1.Quantite = 100;
Produit p2 = new Produit();
p2.Nom = "Stylo";  p2.Prix = 1.2; p2.Quantite = 250;
p1.Afficher();  // Cahier — 3.5 DT x 100 = 350 DT
p2.Afficher();  // Stylo — 1.2 DT x 250 = 300 DT

✓ Correction — Exercice 1.2 (Traçage)

Chaque objet a sa propre copie de Valeur. a est incrémenté 3 fois, b une seule fois.

Sortie : 3 1

2

Encapsulation et propriétés

2. Encapsulation

2.1 Pourquoi encapsuler ?

L'encapsulation consiste à déclarer les attributs en private et à fournir des propriétés (get / set) pour contrôler l'accès et protéger les données.

Problème sans encapsulation :

Etudiant e = new Etudiant();
e.Age = -5;       // Aucune vérification ! Valeur incohérente
e.Moyenne = 250;   // Pas de contrôle sur la plage de valeurs

Solution : rendre les attributs private et exposer des propriétés avec validation.

class Etudiant
{
    private int age;

    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 16 && value <= 60)
                age = value;
            else
                Console.WriteLine("Âge invalide.");
        }
    }
}

2. Encapsulation

2.2 Propriétés automatiques et complètes

Propriété automatique (pas de validation)

class Produit
{
    public string Nom { get; set; }
    public double Prix { get; set; }

    // Propriété en lecture seule
    public double PrixTTC { get { return Prix * 1.19; } }
}

Propriété complète (avec validation)

class CompteBancaire
{
    public string Titulaire { get; set; }
    private double solde;

    public double Solde
    {
        get { return solde; }
        set
        {
            if (value >= 0)
                solde = value;
            else
                Console.WriteLine("Solde négatif interdit.");
        }
    }
}

2. Encapsulation

Exercice d'application

Exercice 2.1 — Classe Employé

Écrivez une classe Employe avec :

Propriété automatique Nom (string)
Propriété Salaire (double) : refuser les valeurs négatives
Propriété en lecture seule SalaireAnnuel qui retourne Salaire * 12
Méthode Afficher() qui affiche nom, salaire mensuel et annuel

Testez avec un employé et tentez d'affecter un salaire négatif.

Exercice 2.2 — Traçage

class Boite
{
    private int taille;
    public int Taille
    {
        get { return taille; }
        set { if (value > 0) taille = value; }
    }
}
// ---
Boite b = new Boite();
b.Taille = 5;
b.Taille = -3;
b.Taille = 10;
Console.WriteLine(b.Taille);

2. Encapsulation

Correction

✓ Correction — Exercice 2.1

class Employe
{
    public string Nom { get; set; }
    private double salaire;
    public double Salaire
    {
        get { return salaire; }
        set { if (value >= 0) salaire = value;
               else Console.WriteLine("Salaire invalide."); }
    }
    public double SalaireAnnuel { get { return Salaire * 12; } }
    public void Afficher()
    {
        Console.WriteLine($"{Nom} — {Salaire} DT/mois — {SalaireAnnuel} DT/an");
    }
}
// ---
Employe emp = new Employe();
emp.Nom = "Khaled"; emp.Salaire = 2500;
emp.Afficher();       // Khaled — 2500 DT/mois — 30000 DT/an
emp.Salaire = -100;  // Salaire invalide.

✓ Correction — Exercice 2.2 (Traçage)

Taille = 5 → accepté (5). Taille = -3 → refusé (reste 5). Taille = 10 → accepté (10).

Sortie : 10

3

Constructeurs

3. Constructeurs

3.1 Constructeur par défaut et constructeur paramétré

Un constructeur est une méthode spéciale appelée automatiquement lors de la création d'un objet. Il porte le même nom que la classe et n'a pas de type de retour.

class Etudiant
{
    public string Nom { get; set; }
    public double Moyenne { get; set; }

    // Constructeur par défaut
    public Etudiant()
    {
        Nom = "Inconnu";
        Moyenne = 0;
    }

    // Constructeur paramétré
    public Etudiant(string nom, double moyenne)
    {
        Nom = nom;
        Moyenne = moyenne;
    }
}

// Utilisation
Etudiant e1 = new Etudiant();                    // Inconnu, 0
Etudiant e2 = new Etudiant("Ali", 14.5);        // Ali, 14.5

3. Constructeurs

3.2 Mot-clé `this` et chaînage

Le mot-clé `this`

this désigne l'objet courant. Il sert à lever l'ambiguïté entre un paramètre et un attribut de même nom.

class Produit
{
    private string nom;
    private double prix;

    public Produit(string nom, double prix)
    {
        this.nom = nom;      // this.nom = attribut, nom = paramètre
        this.prix = prix;
    }
}

Chaînage de constructeurs avec `this(...)`

class Rectangle
{
    public double Largeur { get; set; }
    public double Hauteur { get; set; }

    public Rectangle() : this(1, 1) { }  // Appelle le constructeur ci-dessous

    public Rectangle(double largeur, double hauteur)
    {
        Largeur = largeur;
        Hauteur = hauteur;
    }

    public double Surface() => Largeur * Hauteur;
}

3. Constructeurs

Exercice d'application

Exercice 3.1 — Classe Cercle

Écrivez une classe Cercle avec :

Un attribut Rayon (double)
Un constructeur par défaut qui initialise le rayon à 1
Un constructeur paramétré qui prend le rayon en paramètre
Une méthode Surface() qui retourne π × r²
Une méthode Perimetre() qui retourne 2 × π × r

Créez deux cercles (avec et sans paramètre) et affichez leurs mesures.

Exercice 3.2 — Traçage

class Point
{
    public int X, Y;
    public Point() : this(0, 0) { }
    public Point(int x, int y) { X = x; Y = y; }
}
// ---
Point p1 = new Point();
Point p2 = new Point(3, 7);
Console.WriteLine($"({p1.X},{p1.Y}) ({p2.X},{p2.Y})");

3. Constructeurs

Correction

✓ Correction — Exercice 3.1

class Cercle
{
    public double Rayon { get; set; }

    public Cercle() : this(1) { }
    public Cercle(double rayon) { Rayon = rayon; }

    public double Surface() => Math.PI * Rayon * Rayon;
    public double Perimetre() => 2 * Math.PI * Rayon;
}
// ---
Cercle c1 = new Cercle();
Cercle c2 = new Cercle(5);
Console.WriteLine($"c1 : S={c1.Surface():F2}, P={c1.Perimetre():F2}");
// c1 : S=3.14, P=6.28
Console.WriteLine($"c2 : S={c2.Surface():F2}, P={c2.Perimetre():F2}");
// c2 : S=78.54, P=31.42

✓ Correction — Exercice 3.2 (Traçage)

p1 utilise le constructeur par défaut qui chaîne vers (0,0). p2 utilise (3,7).

Sortie : (0,0) (3,7)

4

Héritage

4. Héritage

4.1 Concept et syntaxe

L'héritage permet à une classe (dérivée / fille) de réutiliser les membres d'une classe existante (base / mère). En C#, l'héritage est simple : une classe ne peut hériter que d'une seule classe.

// Classe de base
class Personne
{
    public string Nom { get; set; }
    public int Age { get; set; }

    public void SePresenter()
    {
        Console.WriteLine($"Je suis {Nom}, {Age} ans.");
    }
}

// Classe dérivée
class Etudiant : Personne
{
    public double Moyenne { get; set; }

    public void AfficherResultat()
    {
        Console.WriteLine($"{Nom} — Moyenne : {Moyenne}");
    }
}

Etudiant e = new Etudiant();
e.Nom = "Fatma";  e.Age = 21;  e.Moyenne = 15.5;
e.SePresenter();       // Hérité de Personne
e.AfficherResultat();  // Propre à Etudiant

4. Héritage

4.2 Constructeur et mot-clé `base`

Le constructeur de la classe dérivée doit appeler le constructeur de la classe de base à l'aide de base(...).

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

    public Personne(string nom, int age)
    {
        Nom = nom;
        Age = age;
    }
}

class Enseignant : Personne
{
    public string Matiere { get; set; }

    public Enseignant(string nom, int age, string matiere)
        : base(nom, age)   // Appel du constructeur de Personne
    {
        Matiere = matiere;
    }

    public void Afficher()
    {
        Console.WriteLine($"{Nom}, {Age} ans, enseigne {Matiere}");
    }
}

Enseignant prof = new Enseignant("Boubaker", 35, "C#");
prof.Afficher();  // Boubaker, 35 ans, enseigne C#

4. Héritage

Exercice d'application

Exercice 4.1 — Hiérarchie Forme

Écrivez :

Une classe de base Forme avec une propriété Couleur (string) et un constructeur paramétré
Une classe Rectangle héritant de Forme, avec Largeur et Hauteur, et une méthode Surface()
Une classe Cercle héritant de Forme, avec Rayon, et une méthode Surface()
Créez un rectangle et un cercle, puis affichez leur couleur et surface

Exercice 4.2 — Traçage

class A
{
    public A() { Console.Write("A "); }
}
class B : A
{
    public B() { Console.Write("B "); }
}
class C : B
{
    public C() { Console.Write("C"); }
}
// ---
C obj = new C();

4. Héritage

Correction

✓ Correction — Exercice 4.1

class Forme
{
    public string Couleur { get; set; }
    public Forme(string couleur) { Couleur = couleur; }
}
class Rectangle : Forme
{
    public double Largeur { get; set; }
    public double Hauteur { get; set; }
    public Rectangle(string c, double l, double h) : base(c)
    { Largeur = l; Hauteur = h; }
    public double Surface() => Largeur * Hauteur;
}
class Cercle : Forme
{
    public double Rayon { get; set; }
    public Cercle(string c, double r) : base(c) { Rayon = r; }
    public double Surface() => Math.PI * Rayon * Rayon;
}
// ---
var rect = new Rectangle("Rouge", 5, 3);
var cer = new Cercle("Bleu", 4);
Console.WriteLine($"{rect.Couleur} : {rect.Surface()}");  // Rouge : 15
Console.WriteLine($"{cer.Couleur} : {cer.Surface():F2}");  // Bleu : 50.27

✓ Correction — Exercice 4.2 (Traçage)

Les constructeurs s'exécutent du parent vers l'enfant : d'abord A, puis B, puis C.

Sortie : A B C

5

Polymorphisme

5. Polymorphisme

5.1 Concept : `virtual` et `override`

Le polymorphisme permet à une méthode d'avoir des comportements différents selon le type réel de l'objet. La classe de base déclare la méthode virtual, et la classe dérivée la redéfinit avec override.

class Forme
{
    public string Nom { get; set; }

    public virtual double Surface()
    {
        return 0;
    }

    public void Afficher()
    {
        Console.WriteLine($"{Nom} — Surface : {Surface():F2}");
    }
}

class Rectangle : Forme
{
    public double Largeur { get; set; }
    public double Hauteur { get; set; }

    public override double Surface()
    {
        return Largeur * Hauteur;
    }
}

class Cercle : Forme
{
    public double Rayon { get; set; }

    public override double Surface()
    {
        return Math.PI * Rayon * Rayon;
    }
}

5. Polymorphisme

5.2 Le polymorphisme en action

Le polymorphisme prend tout son sens lorsqu'on manipule des objets via une référence de type base :

// Création des objets
Rectangle r = new Rectangle { Nom = "Rectangle", Largeur = 5, Hauteur = 3 };
Cercle c = new Cercle { Nom = "Cercle", Rayon = 4 };

// Tableau de type Forme (référence de base)
Forme[] formes = { r, c };

foreach (Forme f in formes)
{
    f.Afficher();  // Appelle le bon Surface() selon le type réel
}
// Rectangle — Surface : 15.00
// Cercle — Surface : 50.27

Point clé : bien que la variable soit de type Forme, c'est la méthode Surface() de la classe réelle (Rectangle ou Cercle) qui est exécutée. C'est la liaison tardive (late binding).

`virtual` vs pas de `virtual`

Scénario	Comportement
`virtual` + `override`	Méthode de la classe réelle appelée (polymorphisme)
Sans `virtual`	Méthode de la classe de la variable appelée (liaison statique)

5. Polymorphisme

Exercice d'application

Exercice 5.1 — Hiérarchie Animal

Écrivez :

Une classe Animal avec une propriété Nom et une méthode virtual string Cri() retournant "..."
Trois classes dérivées : Chat (retourne "Miaou"), Chien (retourne "Ouaf"), Vache (retourne "Meuh")
Créez un tableau Animal[] contenant un chat, un chien et une vache
Parcourez le tableau et affichez : "Nom dit Cri"

Exercice 5.2 — Traçage

class X
{
    public virtual string Info() => "X";
}
class Y : X
{
    public override string Info() => "Y";
}
class Z : Y
{
    public override string Info() => "Z";
}
// ---
X a = new Y();
X b = new Z();
Y c = new Z();
Console.WriteLine($"{a.Info()} {b.Info()} {c.Info()}");

5. Polymorphisme

Correction

✓ Correction — Exercice 5.1

class Animal
{
    public string Nom { get; set; }
    public virtual string Cri() => "...";
}
class Chat : Animal { public override string Cri() => "Miaou"; }
class Chien : Animal { public override string Cri() => "Ouaf"; }
class Vache : Animal { public override string Cri() => "Meuh"; }
// ---
Animal[] animaux = {
    new Chat { Nom = "Minou" },
    new Chien { Nom = "Rex" },
    new Vache { Nom = "Marguerite" }
};
foreach (Animal a in animaux)
    Console.WriteLine($"{a.Nom} dit {a.Cri()}");
// Minou dit Miaou
// Rex dit Ouaf
// Marguerite dit Meuh

✓ Correction — Exercice 5.2 (Traçage)

Grâce au polymorphisme, c'est le type réel qui détermine la méthode : a est un Y, b et c sont des Z.

Sortie : Y Z Z

6

Surcharge de méthodes (Method Overloading)

6. Surcharge de méthodes

6.1 Concept

La surcharge de méthodes (method overloading) permet de définir plusieurs méthodes portant le même nom dans la même classe, mais avec des signatures différentes (nombre ou type de paramètres).

Attention : ne pas confondre surcharge (overloading = même classe, signatures différentes) et redéfinition (overriding = classe dérivée, virtual/override).

class Calculatrice
{
    // Surcharge : même nom, paramètres différents
    public int Additionner(int a, int b)
    {
        return a + b;
    }

    public double Additionner(double a, double b)
    {
        return a + b;
    }

    public int Additionner(int a, int b, int c)
    {
        return a + b + c;
    }
}

Calculatrice calc = new Calculatrice();
Console.WriteLine(calc.Additionner(3, 5));          // 8      (int, int)
Console.WriteLine(calc.Additionner(2.5, 3.7));      // 6.2    (double, double)
Console.WriteLine(calc.Additionner(1, 2, 3));        // 6      (int, int, int)

6. Surcharge de méthodes

6.2 Exemple : classe Afficheur

class Afficheur
{
    public void Afficher(string message)
    {
        Console.WriteLine(message);
    }

    public void Afficher(string message, int fois)
    {
        for (int i = 0; i < fois; i++)
            Console.WriteLine(message);
    }

    public void Afficher(int nombre)
    {
        Console.WriteLine($"Nombre : {nombre}");
    }
}

Afficheur a = new Afficheur();
a.Afficher("Bonjour");       // Bonjour
a.Afficher("Test", 3);        // Test (3 fois)
a.Afficher(42);               // Nombre : 42

Règles de la surcharge

Les méthodes doivent différer par le nombre ou le type des paramètres
Le type de retour seul ne suffit pas à distinguer deux surcharges
Le compilateur choisit la meilleure correspondance à la compilation

6. Surcharge de méthodes

Exercice d'application

Exercice 6.1 — Classe Convertisseur

Écrivez une classe Convertisseur avec des méthodes surchargées Convertir :

Convertir(double celsius) → retourne la température en Fahrenheit (C × 9/5 + 32)
Convertir(double valeur, string unite) → si unite == "km" retourne la valeur en miles (× 0.621), sinon retourne la valeur en km (× 1.609)
Convertir(int minutes) → retourne une chaîne formatée "Xh Ymin"

Testez chaque variante.

Exercice 6.2 — Traçage

class M
{
    public string F(int x) => $"int:{x}";
    public string F(double x) => $"double:{x}";
    public string F(int x, int y) => $"deux:{x+y}";
}
// ---
M m = new M();
Console.WriteLine(m.F(5));
Console.WriteLine(m.F(3.14));
Console.WriteLine(m.F(2, 8));

6. Surcharge de méthodes

Correction

✓ Correction — Exercice 6.1

class Convertisseur
{
    public double Convertir(double celsius)
    {
        return celsius * 9.0 / 5 + 32;
    }
    public double Convertir(double valeur, string unite)
    {
        return unite == "km" ? valeur * 0.621 : valeur * 1.609;
    }
    public string Convertir(int minutes)
    {
        return $"{minutes / 60}h {minutes % 60}min";
    }
}
// ---
var cv = new Convertisseur();
Console.WriteLine(cv.Convertir(100.0));            // 212
Console.WriteLine(cv.Convertir(10.0, "km"));      // 6.21
Console.WriteLine(cv.Convertir(135));              // 2h 15min

✓ Correction — Exercice 6.2 (Traçage)

F(5) appelle F(int), F(3.14) appelle F(double), F(2,8) appelle F(int,int).

Sortie : int:5 → double:3.14 → deux:10

7

Surcharge des opérateurs (Operator Overloading)

7. Surcharge des opérateurs

7.1 Concept et syntaxe

La surcharge des opérateurs permet de redéfinir le comportement d'un opérateur (+, -, ==, etc.) pour une classe personnalisée. La méthode doit être public static et utiliser le mot-clé operator.

Syntaxe générale

public static TypeRetour operator symbole(paramètres)
{
    // logique
}

Opérateurs surchargeables

Catégorie	Opérateurs
Arithmétiques	`+` `-` `*` `/` `%`
Comparaison (par paires)	`==` `!=` \| `<` `>` \| `<=` `>=`
Unaires	`+` `-` `!` `++` `--`

Règle : les opérateurs de comparaison doivent être surchargés par paires : si vous surchargez ==, vous devez aussi surcharger !=.

7. Surcharge des opérateurs

7.2 Exemple : classe Vecteur

class Vecteur
{
    public double X { get; set; }
    public double Y { get; set; }

    public Vecteur(double x, double y) { X = x; Y = y; }

    // Surcharge de +
    public static Vecteur operator +(Vecteur a, Vecteur b)
    {
        return new Vecteur(a.X + b.X, a.Y + b.Y);
    }

    // Surcharge de -
    public static Vecteur operator -(Vecteur a, Vecteur b)
    {
        return new Vecteur(a.X - b.X, a.Y - b.Y);
    }

    // Surcharge de * (scalaire)
    public static Vecteur operator *(Vecteur v, double s)
    {
        return new Vecteur(v.X * s, v.Y * s);
    }

    public override string ToString() => $"({X}, {Y})";
}

var v1 = new Vecteur(3, 4);
var v2 = new Vecteur(1, 2);
Console.WriteLine(v1 + v2);    // (4, 6)
Console.WriteLine(v1 - v2);    // (2, 2)
Console.WriteLine(v1 * 3);     // (9, 12)

7. Surcharge des opérateurs

7.3 Surcharge de `==` et `!=`

class Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public Point(int x, int y) { X = x; Y = y; }

    public static bool operator ==(Point a, Point b)
    {
        return a.X == b.X && a.Y == b.Y;
    }

    public static bool operator !=(Point a, Point b)
    {
        return !(a == b);
    }

    public override string ToString() => $"({X}, {Y})";
}

var p1 = new Point(3, 5);
var p2 = new Point(3, 5);
var p3 = new Point(1, 2);

Console.WriteLine(p1 == p2);  // True  (mêmes coordonnées)
Console.WriteLine(p1 == p3);  // False
Console.WriteLine(p1 != p3);  // True

Sans surcharge de ==, la comparaison vérifie si les deux variables pointent vers le même objet en mémoire (référence), et non si les valeurs sont égales.

7. Surcharge des opérateurs

Exercice d'application

Exercice 7.1 — Classe Fraction

Écrivez une classe Fraction (Numérateur, Dénominateur) avec :

Un constructeur paramétré
Surcharge de + : addition de deux fractions (a/b + c/d = (a*d + c*b) / (b*d))
Surcharge de * : multiplication (a/b * c/d = (a*c) / (b*d))
Redéfinition de ToString() pour afficher sous la forme "Num/Den"

Testez avec 1/2 + 1/3 et 2/3 * 3/4.

Exercice 7.2 — Traçage

class Poids
{
    public double Kg { get; set; }
    public Poids(double kg) { Kg = kg; }
    public static Poids operator +(Poids a, Poids b)
        => new Poids(a.Kg + b.Kg);
    public static bool operator >(Poids a, Poids b) => a.Kg > b.Kg;
    public static bool operator <(Poids a, Poids b) => a.Kg < b.Kg;
}
// ---
var a = new Poids(2.5);
var b = new Poids(3.0);
var c = a + b;
Console.WriteLine(c.Kg);
Console.WriteLine(a > b);
Console.WriteLine(a < b);

7. Surcharge des opérateurs

Correction

✓ Correction — Exercice 7.1

class Fraction
{
    public int Num { get; set; }
    public int Den { get; set; }

    public Fraction(int num, int den) { Num = num; Den = den; }

    public static Fraction operator +(Fraction a, Fraction b)
        => new Fraction(a.Num * b.Den + b.Num * a.Den, a.Den * b.Den);

    public static Fraction operator *(Fraction a, Fraction b)
        => new Fraction(a.Num * b.Num, a.Den * b.Den);

    public override string ToString() => $"{Num}/{Den}";
}
// ---
var f1 = new Fraction(1, 2);
var f2 = new Fraction(1, 3);
Console.WriteLine(f1 + f2);  // 5/6
var f3 = new Fraction(2, 3);
var f4 = new Fraction(3, 4);
Console.WriteLine(f3 * f4);  // 6/12

✓ Correction — Exercice 7.2 (Traçage)

c = 2.5 + 3.0 = 5.5. a > b : 2.5 > 3.0 = false. a < b : 2.5 < 3.0 = true.

Sortie : 5.5 → False → True

Récapitulatif des concepts

Concept	Mot-clé	Description
Classe / Objet	`class`, `new`	Modèle et instance concrète
Encapsulation	`private`, `get`, `set`	Contrôle de l'accès aux données
Constructeur	`this`	Initialisation à la création de l'objet
Héritage	`:`, `base`	Réutilisation de la classe de base
Polymorphisme	`virtual`, `override`	Comportement variable selon le type réel
Surcharge de méthodes	—	Même nom, signatures différentes
Surcharge d'opérateurs	`operator`	Redéfinir `+`, `-`, `==`, etc.

Résumé du chapitre

Concepts clés

Classe = modèle, objet = instance
Encapsulation avec get/set
Constructeurs et chaînage (this)
Héritage simple (:, base)

Polymorphisme

virtual dans la classe de base
override dans la classe dérivée
Liaison tardive (late binding)

Surcharge

Méthodes : même nom, signatures différentes
Opérateurs : public static operator
Comparaison : par paires (==/!=)

Prochain chapitre

Classes abstraites
Interfaces
Classes scellées (sealed)
Casting et vérification de type (is, as)

Fin du Chapitre 3

Questions ?

Enseignant : Boubaker KHMILI

ISAE Gafsa — 2026/2027

Objectifs du chapitre

Plan du chapitre

Classes et objets

1. Classes et objets

1.1 Concept fondamental

1. Classes et objets

1.2 Déclaration d'une classe

Modificateurs d'accès

1. Classes et objets

1.3 Instanciation et utilisation

1. Classes et objets

Exercice d'application

Exercice 1.1 — Classe Produit

Exercice 1.2 — Traçage

1. Classes et objets

Correction — Exercice 1.1

✓ Correction

✓ Correction — Exercice 1.2 (Traçage)

Encapsulation et propriétés

2. Encapsulation

2.1 Pourquoi encapsuler ?

2. Encapsulation

2.2 Propriétés automatiques et complètes

Propriété automatique (pas de validation)

Propriété complète (avec validation)

2. Encapsulation

Exercice d'application

Exercice 2.1 — Classe Employé

Exercice 2.2 — Traçage

2. Encapsulation

Correction

✓ Correction — Exercice 2.1

✓ Correction — Exercice 2.2 (Traçage)

Constructeurs

3. Constructeurs

3.1 Constructeur par défaut et constructeur paramétré

3. Constructeurs

3.2 Mot-clé this et chaînage

Le mot-clé this

Chaînage de constructeurs avec this(...)

3. Constructeurs

Exercice d'application

Exercice 3.1 — Classe Cercle

Exercice 3.2 — Traçage

3. Constructeurs

Correction

✓ Correction — Exercice 3.1

✓ Correction — Exercice 3.2 (Traçage)

Héritage

4. Héritage

4.1 Concept et syntaxe

4. Héritage

4.2 Constructeur et mot-clé base

4. Héritage

Exercice d'application

Exercice 4.1 — Hiérarchie Forme

Exercice 4.2 — Traçage

4. Héritage

Correction

✓ Correction — Exercice 4.1

✓ Correction — Exercice 4.2 (Traçage)

Polymorphisme

5. Polymorphisme

5.1 Concept : virtual et override

5. Polymorphisme

5.2 Le polymorphisme en action

virtual vs pas de virtual

5. Polymorphisme

Exercice d'application

Exercice 5.1 — Hiérarchie Animal

Exercice 5.2 — Traçage

5. Polymorphisme

Correction

✓ Correction — Exercice 5.1

✓ Correction — Exercice 5.2 (Traçage)

Surcharge de méthodes (Method Overloading)

6. Surcharge de méthodes

6.1 Concept

6. Surcharge de méthodes

6.2 Exemple : classe Afficheur

3.2 Mot-clé `this` et chaînage

Le mot-clé `this`

Chaînage de constructeurs avec `this(...)`

4.2 Constructeur et mot-clé `base`

5.1 Concept : `virtual` et `override`

`virtual` vs pas de `virtual`

7.3 Surcharge de `==` et `!=`