C# utilise le mot clé override pour signifier que la méthode dans la classe dérivée surcharge la méthode héritée. Le mot clé new définit la méthode comme une nouvelle méthode indépendante de celle de la classe de base. Voyons comment ça marche.

Fonctionnement de l’héritage en C#

On utilise le mot clé virtual lorsqu’on veut qu’une méthode puisse être héritée en C#.

    public class Animal
    {
        public virtual void SeDeplace()
        {
            Console.WriteLine("se deplace");
        }
    }

Le mot clé override permet à la méthode de surcharger la méthode de la classe de base. Les objets de la classe dérivée utiliseront cette méthode.

    public class Chien : Animal
    {
        public override void SeDeplace()
        {
            Console.WriteLine("marche");
        }
    }

    public class Serpent : Animal
    {
        public override void SeDeplace()
        {
            Console.WriteLine("rampe");
        }
    }

Chaque classe utilisera la méthode « overridée ».

            Animal animal = new Animal();
            animal.SeDeplace(); // affiche se deplace

            Animal chien = new Chien();
            chien.SeDeplace(); // affiche marche

            Animal serpent = new Serpent();
            serpent.SeDeplace(); // affiche rampe

Le mot clé new

Si on crée une classe qui hérite de Animal et qu’on définit une méthode SeDeplace en utilisant le mot clé New, la nouvelle méthode remplacera la méthode de la classe mère. Elle se comportera comme si celle-ci n’existait pas. On dit que la méthode virtuelle est masquée.

    public class Grenouille : Animal
    {
         public new void SeDeplace()
        {
            Console.WriteLine("saute");
        }
    }

Si on crée un Animal, la classe créée utilisera la méthode de la classe Animal. Car la classe Animal n’a aucune connaissance de l’existence de la méthode créée avec New.

            Animal grenouille = new Grenouille();
            grenouille.SeDeplace(); // affiche se deplace

Par contre si On crée un objet Grenouille, la classe Grenouille appellera sa propre méthode.

            Grenouille grenouille2 = new Grenouille();
            grenouille2.SeDeplace(); // affiche saute

Mettre new revient presque qu’à ne mettre ni new, ni override, à la différence près qu’une warning s’affichera. Créons par exemple, la classe Pigeon.

    public class Pigeon : Animal
    {
        public void SeDeplace()
        {
            Console.WriteLine("vole");
        }
    }

Le compilateur affiche le message suivant: Avertissement CS0114 ‘Pigeon.SeDeplace()’ masque le membre hérité ‘Animal.SeDeplace()’. Pour que le membre actif se substitue à cette implémentation, ajoutez le mot clé override.

 Pigeon pigeon = new Pigeon();   
 pigeon.SeDeplace(); // affiche vole

Voilà!