Sorciers et guerriers

Héritage

En C#, on peut définir une hiérarchie de classes à l'aide de l'héritage, ce qui permet à une classe dérivée (Car) d'hériter du comportement et des données de sa classe parente (Vehicle). Si aucune classe parente n'est spécifiée, la classe hérite de la classe object.

Les classes parentes peuvent fournir des fonctionnalités aux classes dérivées de trois manières :

• Définir une méthode normale.
• Définir une méthode virtual, qui est comme une méthode normale mais que les classes dérivées peuvent modifier.
• Définir une méthode abstract, qui est une méthode sans implémentation que les classes dérivées doivent implémenter. Une classe avec des méthodes abstract doit également être marquée comme abstract. Les classes abstraites ne peuvent pas être instanciées.

Le modificateur d'accès protected permet d'accéder à un membre de la classe parente depuis une classe dérivée, mais bloque l'accès depuis les autres classes.

Les classes dérivées peuvent accéder aux membres de la classe parente via le mot-clé base.

// Inherits from the 'object' class
abstract class Vehicle
{
    // Can be overridden
    public virtual void Drive()
    {
    }

    // Must be overridden
    protected abstract int Speed();
}

class Car : Vehicle
{
    public override void Drive()
    {
        // Override virtual method

        // Call parent implementation
        base.Drive();
    }

    protected override int Speed()
    {
        // Implement abstract method
    }
}

Le constructeur d'une classe dérivée appelle automatiquement le constructeur de sa classe parente avant d'exécuter la logique de son propre constructeur. On peut passer des arguments au constructeur d'une classe parente à l'aide du mot-clé base :

abstract class Vehicle
{
    protected Vehicle(int wheels)
    {
        Console.WriteLine("Called first");
    }
}

class Car : Vehicle
{
    public Car() : base(4)
    {
        Console.WriteLine("Called second");
    }
}

Lorsque plusieurs classes dérivent d'une classe de base, ces deux (ou plus) classes implémentent souvent des versions différentes d'une méthode de la classe de base. C'est un principe très important appelé polymorphisme. Par exemple, dans une variante de l'exemple ci-dessus, on montre comment du code utilisant Vehicle peut changer de comportement selon le type de véhicule qui a été instancié.

abstract class Vehicle
{
   public abstract string GetDescription();
}

class Car : Vehicle
{
   public Car()
   {
   }

   public override string GetDescription()
   {
      return "Runabout";
   }
}

class Rig : Vehicle
{
   public Rig()
   {
   }

   public override string GetDescription()
   {
      return "Big Rig";
   }
}

Vehicle v1 = new Car();
Vehicle v2 = new Rig();

v1.GetDescription();
// => Runabout
v2.GetDescription();
// => Big Rig