Maîtriser les classes et méthodes abstraites C# : Guide pratique

Maîtriser les classes et méthodes abstraites C#

Explorez les classes et méthodes abstraites C# à travers des exemples clairs, patterns d'héritage, constructeurs et cas d'utilisation réels.

Classe Abstraite

En C#, les classes abstraites servent de templates qui ne peuvent pas être instanciées directement. Le mot-clé abstract signale qu'une classe est destinée à être sous-classée. Par exemple :

// Définir une classe abstraite
abstract class Langage {
    // Champs et méthodes
}
// Tenter de créer une instance lance une erreur
// Langage obj = new Langage();

Une classe abstraite peut contenir à la fois des méthodes abstraites (déclarations sans corps) et des méthodes concrètes (entièrement implémentées). Par exemple :

abstract class Langage {
    // Méthode abstraite – sans corps
    public abstract void Afficher();
    // Méthode concrète – a une implémentation
    public void AfficherInfo() {
        Console.WriteLine("Méthode concrète dans classe abstraite");
    }
}

Avant de continuer, assurez-vous d'être à l'aise avec les concepts d'héritage C#.

---

Héritage d'une classe abstraite

Puisque vous ne pouvez pas instancier une classe abstraite directement, vous devez créer une sous-classe concrète qui en dérive. La sous-classe hérite des membres de la classe abstraite, vous permettant de les utiliser via l'objet dérivé. Exemple :

using System;
namespace AbstractClassDemo {
    abstract class Langage {
        public void Afficher() {
            Console.WriteLine("Méthode concrète dans classe abstraite");
        }
    }
    // Sous-classe concrète
    class Program : Langage {
        static void Main(string[] args) {
            Program prog = new Program();
            prog.Afficher();
            Console.ReadLine();
        }
    }
}

Sortie

Méthode concrète dans classe abstraite

Dans cet exemple, Langage est abstrait, tandis que Program en hérite et peut appeler Afficher(). Notez que les classes abstraites ne peuvent pas être sealed ; elles doivent toujours servir de types de base.

Note : Utilisez ce pattern quand vous avez besoin d'un contrat commun que plusieurs types dérivés implémenteront.

---

Méthodes Abstraites en C#

Une méthode abstraite déclare une signature sans corps. Elle oblige les classes dérivées non-abstraites à fournir une implémentation. Par exemple :

public abstract void Afficher();

Seules les classes abstraites peuvent contenir des méthodes abstraites. Quand une sous-classe concrète hérite d'une telle classe, elle doit surcharger chaque membre abstrait à moins qu'elle ne se déclare elle-même abstraite.

Exemple : Implémentation d'une méthode abstraite

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        public abstract void FaireSon();
    }
    class Chien : Animal {
        public override void FaireSon() {
            Console.WriteLine("Ouaf Ouaf");
        }
    }
    class Program {
        static void Main(string[] args) {
            Chien chien = new Chien();
            chien.FaireSon();
            Console.ReadLine();
        }
    }
}

Sortie

Ouaf Ouaf

Ici, Animal déclare une méthode abstraite FaireSon(). La sous-classe concrète Chien fournit la surcharge, remplissant le contrat.

Note : Les méthodes abstraites sont implicitement virtual ; donc le mot-clé virtual est inutile et non autorisé.

---

Propriétés Abstraites avec Getters et Setters

Les accesseurs abstraits permettent aux classes dérivées de fournir une logique personnalisée pour les opérations get et set de propriété. Exemple :

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        protected string nom;
        public abstract string Nom { get; set; }
    }
    class Chien : Animal {
        public override string Nom {
            get { return nom; }
            set { nom = value; }
        }
    }
    class Program {
        static void Main(string[] args) {
            Chien chien = new Chien();
            chien.Nom = "Tom";
            Console.WriteLine("Nom : " + chien.Nom);
            Console.ReadLine();
        }
    }
}

Sortie

Nom : Tom

La classe dérivée implémente la propriété abstraite, permettant une gestion d'état encapsulée.

---

Constructeurs dans les Classes Abstraites

Les classes abstraites peuvent définir des constructeurs pour initialiser l'état partagé pour toutes les sous-classes. Quand une instance de sous-classe est créée, le constructeur de la classe abstraite s'exécute en premier. Exemple :

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        public Animal() {
            Console.WriteLine("Constructeur Animal");
        }
    }
    class Chien : Animal {
        public Chien() {
            Console.WriteLine("Constructeur Chien");
        }
    }
    class Program {
        static void Main(string[] args) {
            Chien d1 = new Chien();
            Console.ReadLine();
        }
    }
}

Sortie

Constructeur Animal
Constructeur Chien

Les sous-classes peuvent aussi définir des destructeurs si une logique de nettoyage est nécessaire.

Note : Les constructeurs sont utiles pour configurer des ressources communes requises par tous les types dérivés.

---

Abstraction C# via les Classes Abstraites

Les classes abstraites fournissent un mécanisme d'abstraction : elles masquent les détails d'implémentation tout en exposant une interface propre. Cela simplifie les systèmes complexes en se concentrant sur le « quoi » plutôt que le « comment ».

Considérez une analogie du monde réel : les systèmes de freinage sur les motos. Le comportement externe du frein — ralentir ou arrêter la moto — est cohérent, mais le mécanisme sous-jacent varie entre modèles. Les classes abstraites laissent chaque modèle implémenter sa logique de freinage unique sans altérer le contrat externe.

Exemple : Freins de Moto

using System;
namespace AbstractClassDemo {
    abstract class Moto {
        public abstract void Freiner();
    }
    class MotoSport : Moto {
        public override void Freiner() {
            Console.WriteLine("Frein Moto Sport");
        }
    }
    class MotoMontagne : Moto {
        public override void Freiner() {
            Console.WriteLine("Frein Moto Montagne");
        }
    }
    class Program {
        static void Main(string[] args) {
            MotoSport s1 = new MotoSport();
            s1.Freiner();
            MotoMontagne m1 = new MotoMontagne();
            m1.Freiner();
            Console.ReadLine();
        }
    }
}

Sortie

Frein Moto Sport
Frein Moto Montagne

Ici, Moto déclare une méthode abstraite Freiner(). Chaque classe de moto concrète fournit son implémentation spécifique, démontrant le polymorphisme.

Note : Pour une abstraction complète — aucune implémentation de base — envisagez d'utiliser des interfaces à la place.