C # - Polymorphisme

Le mot polymorphismsignifie 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. Dansstatic polymorphism, la réponse à une fonction est déterminée au moment de la compilation. Dansdynamic polymorphism, il est décidé au moment de l'exécution.

Polymorphisme statique

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

• Surcharge de fonction
• Surcharge de l'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 portée. La définition de la fonction doit différer les unes des autres 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 diffèrent uniquement par le type de retour.

L'exemple suivant montre l'utilisation de la fonction print() pour imprimer différents types de données -

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 qui sont 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.AbstractLes 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

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

Le programme suivant montre une classe abstraite -

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 plusieurs classes héritées, vous utilisez virtualles fonctions. Les fonctions virtuelles pourraient ê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 mis en œuvre par abstract classes et virtual functions.

Le programme suivant le démontre -

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