C # polymorphisme

polymorphisme statique

Au moment de la compilation, les fonctions et les objets du mécanisme de connexion est appelé liaison anticipée, également connu sous le nom de liaison statique. C # propose deux techniques pour mettre en œuvre le polymorphisme statique. Ils sont:

• Fonction surcharge
• Surcharge de l'opérateur

Opérateur surcharge discutera dans la prochaine section, nous allons discuter de la surcharge de fonction suivante.

Fonction surcharge

Vous pouvez être dans la même gamme pour le même nom de fonction a plusieurs définitions. fonctions définies doivent être différents les uns des autres peut être une liste de paramètres types de paramètres, peut aussi être un certain nombre de paramètres différents. Vous ne pouvez pas être surchargé que par type de la déclaration de fonction de retour.

L'exemple suivant montre plusieurs de la mêmeimpression de fonction (),pour l' impression de différents types de données:

using System;
namespace PolymorphismApplication
{
   classe printData
   {
      void print (int i)
      {
         Console.WriteLine ( "int d'impression: {0}", i);
      }

      void print (double f)
      {
         Console.WriteLine ( "float d'impression: {0}", f);
      }

      void print (string s)
      {
         Console.WriteLine ( "chaîne d'impression: {0}", s);
      }
      static void Main (string [] args)
      {
         p printData = new printData ();
         // Invoque impression pour imprimer un p.print entier (5);
         // Invoque impression pour imprimer float p.print (500,263);
         // Invoke imprimer la p.print de chaîne d'impression ( "Bonjour C ++");
         Console.ReadKey ();
      }
   }
}

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

int d'impression: 5
float d'impression: 500,263
chaîne d'impression: Bonjour C ++

polymorphisme dynamique

C # vous permet d'utiliser le mot - cléabstrait pour créer une classe abstraite, la mise en œuvre de l' interface fournit une partie de la classe.Quand une classe dérivée hérite de la classe abstraite pour atteindre complète.Résumé classe contient des méthodes abstraites, des méthodes abstraites peuvent être mises en œuvre comme une classe dérivée.Les classes dérivées ont des fonctions plus spécialisées.

S'il vous plaît noter que les éléments suivants sont quelques règles pour 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.
• En plaçant devant les mots - clés de définition de classescellés, la classe peut être déclarée en tant que classes scellées.Quand une classe est déclaréescellé, il ne peut pas être héritée.Une classe abstraite ne peut pas être déclarée comme scellé.

Le programme suivant illustre une classe abstraite:

using System;
namespace PolymorphismApplication
{
   Forme de classe abstraite
   {
      public abstract zone int ();
   }
   classe Rectangle: Forme
   {
      int length privé;
      Largeur int privé;
      Rectangle publique (int a = 0, int b = 0)
      {
         longueur = a;
         width = b;
      }
      public override zone int ()
      { 
         Console.WriteLine ( "zone de classe Rectangle:");
         retour (largeur * longueur); 
      }
   }

   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Rectangle r = new Rectangle (10, 7);
         une double = r.area ();
         Console.WriteLine ( "Taille: {0}", a);
         Console.ReadKey ();
      }
   }
}

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

Classe Rectangle:
Surface: 70

Quand une fonction est définie dans les besoins de la classe à mettre en œuvre dans une classe dérivée, vous pouvez utiliser desméthodes virtuelles.méthode virtuelle est déclarée en utilisant le mot - clévirtuel.Les méthodes virtuelles peuvent être mises en œuvre différemment selon les classes héritées. Les appels vers les méthodes virtuelles se produit lors de l'exécution.

polymorphisme dynamique est réalisée par lesclasses abstraites et des méthodes virtuelles.

Le programme suivant illustre ce point:

using System;
namespace PolymorphismApplication
{
   Forme de classe 
   {
      largeur de protection int, hauteur;
      Forme publique (int a = 0, int b = 0)
      {
         largeur = a;
         height = b;
      }
      publique zone int virtual ()
      {
         Console.WriteLine ( "zone de parent:");
         return 0;
      }
   }
   classe Rectangle: Forme
   {
      Rectangle publique (int a = 0, int b = 0): base (a, b)
      {

      }
      public override zone int ()
      {
         Console.WriteLine ( "zone de classe Rectangle:");
         retour (largeur * hauteur); 
      }
   }
   classe Triangle: Forme
   {
      publique Triangle (int a = 0, int b = 0): base (a, b)
      {
      
      }
      public override zone int ()
      {
         Console.WriteLine ( "zone de classe Triangle:");
         retour (largeur * hauteur / 2); 
      }
   }
   classe Caller
   {
      CallArea public void (Shape sh)
      {
         int a;
         a = sh.area ();
         Console.WriteLine ( "Taille: {0}", a);
      }
   }  
   Testeur de classe
   {
      
      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:

Classe Rectangle:
Surface: 70
zone Classe Triangle:
Surface: 25