C# - Polymorphisme

Le mot polymorphisme signifie avoir plusieurs formes. Dans le paradigme de la programmation orientée objet, le polymorphisme est souvent exprimé comme "une interface, plusieurs fonctions".

Le polymorphisme peut être statique ou dynamique. En polymorphisme statique , la réponse à une fonction est déterminée au moment de la compilation. En polymorphisme dynamique , il est décidé au moment de l'exécution.

Polymorphisme statique

Le mécanisme de liaison d'une fonction à un objet au moment de la compilation est appelé liaison anticipée. Elle est également appelée liaison statique. C# fournit deux techniques pour implémenter le polymorphisme statique. Ils sont −

• Surcharge de fonction
• Surcharge d'opérateur

Nous discutons de la surcharge des opérateurs dans le chapitre suivant.

Surcharge de fonction

Vous pouvez avoir plusieurs définitions pour le même nom de fonction dans la même étendue. La définition de la fonction doit différer l'une de l'autre par les types et/ou le nombre d'arguments dans la liste d'arguments. Vous ne pouvez pas surcharger les déclarations de fonction qui ne diffèrent que par le type de retour.

L'exemple suivant montre comment utiliser la fonction print() pour imprimer différents types de données −

Démo en direct

using System;

namespace PolymorphismApplication {
   class Printdata {
      void print(int i) {
         Console.WriteLine("Printing int: {0}", i );
      }
      void print(double f) {
         Console.WriteLine("Printing float: {0}" , f);
      }
      void print(string s) {
         Console.WriteLine("Printing string: {0}", s);
      }
      static void Main(string[] args) {
         Printdata p = new Printdata();
         
         // Call print to print integer
         p.print(5);
         
         // Call print to print float
         p.print(500.263);
         
         // Call print to print string
         p.print("Hello C++");
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

Printing int: 5
Printing float: 500.263
Printing string: Hello C++

Polymorphisme dynamique

C# vous permet de créer des classes abstraites utilisées pour fournir une implémentation de classe partielle d'une interface. L'implémentation est terminée lorsqu'une classe dérivée en hérite. Résumé les classes contiennent des méthodes abstraites, qui sont implémentées par la classe dérivée. Les classes dérivées ont des fonctionnalités plus spécialisées.

Voici les règles sur les classes abstraites −

• Vous ne pouvez pas créer une instance d'une classe abstraite

• Vous ne pouvez pas déclarer une méthode abstraite en dehors d'une classe abstraite

• Lorsqu'une classe est déclarée scellée , il ne peut pas être hérité, les classes abstraites ne peuvent pas être déclarées scellées.

Le programme suivant illustre une classe abstraite −

Démo en direct

using System;

namespace PolymorphismApplication {
   abstract class Shape {
      public abstract int area();
   }
   
   class Rectangle:  Shape {
      private int length;
      private int width;
      
      public Rectangle( int a = 0, int b = 0) {
         length = a;
         width = b;
      }
      public override int area () { 
         Console.WriteLine("Rectangle class area :");
         return (width * length); 
      }
   }
   class RectangleTester {
      static void Main(string[] args) {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("Area: {0}",a);
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

Rectangle class area :
Area: 70

Lorsque vous avez une fonction définie dans une classe que vous souhaitez implémenter dans une ou des classes héritées, vous utilisez virtuel les fonctions. Les fonctions virtuelles peuvent être implémentées différemment dans différentes classes héritées et l'appel à ces fonctions sera décidé au moment de l'exécution.

Le polymorphisme dynamique est implémenté par des classes abstraites et fonctions virtuelles .

Le programme suivant le démontre −

Démo en direct

using System;

namespace PolymorphismApplication {
   class Shape {
      protected int width, height;
      
      public Shape( int a = 0, int b = 0) {
         width = a;
         height = b;
      }
      public virtual int area() {
         Console.WriteLine("Parent class area :");
         return 0;
      }
   }
   class Rectangle: Shape {
      public Rectangle( int a = 0, int b = 0): base(a, b) {

      }
      public override int area () {
         Console.WriteLine("Rectangle class area :");
         return (width * height); 
      }
   }
   class Triangle: Shape {
      public Triangle(int a = 0, int b = 0): base(a, b) {
      }
      public override int area() {
         Console.WriteLine("Triangle class area :");
         return (width * height / 2); 
      }
   }
   class Caller {
      public void CallArea(Shape sh) {
         int a;
         a = sh.area();
         Console.WriteLine("Area: {0}", a);
      }
   }  
   class Tester {
      static void Main(string[] args) {
         Caller c = new Caller();
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         
         c.CallArea(r);
         c.CallArea(t);
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

Rectangle class area:
Area: 70
Triangle class area:
Area: 25