[Tutoriel C#] Polymorphisme C#

Polymorphisme C#

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

Le polymorphisme peut être statique ou dynamique. Dans le polymorphisme statique, la réponse de la fonction se produit au moment de la compilation. Dans le polymorphisme dynamique, la réponse d'une fonction se produit au moment de l'exécution.

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. Ce sont :

Surcharge de fonctions

Surcharge d'opérateurs

La surcharge d'opérateurs sera abordée dans le chapitre suivant, puis nous discuterons 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(), utilisées 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é, il générera 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. Les classes abstraites contiennent 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 scellée en plaçant le mot clé scellé devant la définition de la classe. Lorsqu'une classe est déclarée 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 Quand il y a est une fonction définie dans une classe qui doit être implémentée dans une classe héritée, des méthodes virtuelles peuvent être utilisées. Les méthodes virtuelles sont déclarées à l'aide du mot-clé virtual. 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

C'est tout [Tutoriel C# ] Contenu du polymorphisme C#, veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !