Polymorphisme C#

Polymorphisme statique

Au moment de la compilation, le mécanisme de connexion des fonctions et des objets est appelé liaison précoce, également appelée liaison statique. C# fournit deux techniques pour implémenter le polymorphisme statique. Il s'agit de :

• Surcharge de fonctions

• Surcharge d'opérateur

La surcharge d'opérateur sera abordée dans le Dans la section du chapitre suivant, nous discuterons ensuite de la surcharge de fonctions.

Surcharge de fonctions

Vous pouvez avoir plusieurs définitions du même nom de fonction dans la même portée. Les définitions de fonctions doivent différer les unes des autres, soit par le type de paramètres dans la liste des paramètres, soit par le nombre de paramètres. Les déclarations de fonction qui diffèrent uniquement par le type de retour ne peuvent pas être surchargées.

L'exemple suivant montre plusieurs fonctions identiques 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();
         // 调用 print 来打印整数
         p.print(5);
         // 调用 print 来打印浮点数
         p.print(500.263);
         // 调用 print 来打印字符串
         p.print("Hello C++");
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, ce qui produit les résultats suivants :

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

Polymorphisme dynamique

C# vous permet d'utiliser le mot-clé abstract pour créer des classes abstraites qui fournissent des implémentations de classes partielles d'une interface . L'implémentation est terminée lorsqu'une classe dérivée hérite de cette classe abstraite. La Classe abstraitecontient des méthodes abstraites, qui peuvent être implémentées par des classes dérivées. Les classes dérivées ont des fonctionnalités plus spécialisées.

Veuillez noter que voici quelques règles concernant 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.

• Une classe peut être déclarée comme classe scellée en plaçant le mot-clé scellé devant la définition de la classe. Lorsqu'une classe est déclarée comme scellée, elle ne peut pas être héritée. Les classes abstraites ne peuvent pas être déclarées scellées.

Le programme suivant présente 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 类的面积：");
         return (width * length); 
      }
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("面积： {0}",a);
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Rectangle 类的面积：
面积： 70

Quand il existe une fonction définie dans une classe qui doit être implémentée dans une classe héritée, vous pouvez utiliser la méthode virtuelle. Les méthodes virtuelles sont déclarées à l'aide du mot-clé virtuel. Les méthodes virtuelles peuvent avoir différentes implémentations dans différentes classes héritées. Les appels aux méthodes virtuelles se produisent au moment de l'exécution.

Le polymorphisme dynamique est obtenu grâce à des classes abstraites et des méthodes virtuelles.

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("父类的面积：");
         return 0;
      }
   }
   class Rectangle: Shape
   {
      public Rectangle( int a=0, int b=0): base(a, b)
      {

      }
      public override int area ()
      {
         Console.WriteLine("Rectangle 类的面积：");
         return (width * height); 
      }
   }
   class Triangle: Shape
   {
      public Triangle(int a = 0, int b = 0): base(a, b)
      {
      
      }
      public override int area()
      {
         Console.WriteLine("Triangle 类的面积：");
         return (width * height / 2); 
      }
   }
   class Caller
   {
      public void CallArea(Shape sh)
      {
         int a;
         a = sh.area();
         Console.WriteLine("面积： {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 les résultats suivants :

Rectangle 类的面积：
面积：70
Triangle 类的面积：
面积：25