C # polymorphism

Statische Polymorphismus

Beim Kompilieren wird die Verbindungsmechanismus Funktionen und Objekte der frühen Bindung, auch bekannt als statische Bindung genannt. C # bietet zwei Techniken statische Polymorphismus zu implementieren. Es sind dies:

• Überladen von Funktionen
• Überladen von Operatoren

Überladen von Operatoren im nächsten Abschnitt diskutieren, werden wir die folgende Funktion Überlastung zu diskutieren.

Überladen von Funktionen

Sie können in der gleichen Größenordnung sein für die gleiche Funktionsnamen mehrere Definitionen hat. Definierte Funktionen muss sich von jeder anderen Parameterliste Parametertypen sein kann, kann auch eine Reihe verschiedener Parameter sein. Sie können nicht nur durch Rückgabetyp der Funktionsdeklaration überlastet werden.

Das folgende Beispiel zeigt einige der gleichen Funktionprint (), zum Drucken von verschiedenen Arten von Daten:

using System;
Namespace PolymorphismApplication
{
   Klasse 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 Invoke eine ganze Zahl p.print (5) zu drucken;
         // Invoke Druck float p.print (500,263) zu drucken;
         // Invoke auf die Druckzeichenfolge p.print ( "Hallo C ++") drucken;
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Drucken int: 5
Drucken float: 500,263
Druck string: Hallo C ++

Dynamische Polymorphismus

C # können Sie das Stichwortabstrakt verwenden eine abstrakte Klasse, Interface - Implementierung bietet für einen Teil der Klasse zu erstellen.Wenn eine abgeleitete Klasse von der abstrakten Klasse erbt vollständig zu erreichen.Abstrakte Klasse enthält abstrakte Methoden können abstrakte Methoden als einer abgeleiteten Klasse implementiert werden.Abgeleitete Klassen haben mehr spezialisierte Funktionen.

Bitte beachten Sie, dass die folgenden sind einige Regeln für abstrakte Klassen:

• Sie können keine Instanz einer abstrakten Klasse erstellen.
• Sie können nicht eine abstrakte Methode außerhalb einer abstrakten Klasse deklarieren.
• Durch die Platzierung vor der Klassendefinition Schlüsselwörterversiegelt, kann die Klasse als versiegelte Klassendeklariertwerden.Wenn eine Klasseversiegelt ist erklärt worden ist ,kann es nicht vererbt werden. Eine abstrakte Klasse kann nicht als versiegelt deklariert werden.

Das folgende Programm zeigt eine abstrakte Klasse:

using System;
Namespace PolymorphismApplication
{
   abstrakte Klasse-Form
   {
      public abstract int Bereich ();
   }
   Klasse Rectangle: Form
   {
      private int Länge;
      private int Breite;
      public Rectangle (int a = 0, int b = 0)
      {
         Länge = a;
         width = b;
      }
      public override int Bereich ()
      { 
         Console.WriteLine ( "Rectangle-Klasse-Bereich:");
         return (Breite * Länge); 
      }
   }

   Klasse RectangleTester
   {
      static void Main (string [] args)
      {
         Rectangle r = new Rectangle (10, 7);
         Doppel a = r.area ();
         Console.WriteLine ( "Größe: {0}", a);
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Rectangle-Klasse Größe:
Fläche: 70

Wenn eine Funktion in der Klasse Bedürfnisse definiert ist in einer abgeleiteten Klasse implementiert werden, können Sievirtuelle Methoden verwenden.Virtuelle Methode deklariert das Schlüsselwortvirtual verwenden.Virtuelle Methoden können in verschiedenen geerbten Klassen unterschiedlich implementiert werden. Anrufe auf virtuelle Methoden erfolgt zur Laufzeit.

Dynamische Polymorphismus wird durchabstrakte Klassen und virtuelle Methoden erreicht.

Das folgende Programm veranschaulicht diesen Punkt:

using System;
Namespace PolymorphismApplication
{
   Klasse-Form 
   {
      geschützt int Breite, Höhe;
      public Shape (int a = 0, int b = 0)
      {
         width = a;
         height = b;
      }
      public virtual int Bereich ()
      {
         Console.WriteLine ( "Mutterbereich:");
         return 0;
      }
   }
   Klasse Rectangle: Form
   {
      public Rectangle (int a = 0, int b = 0): Basis (a, b)
      {

      }
      public override int Bereich ()
      {
         Console.WriteLine ( "Rectangle-Klasse-Bereich:");
         Rückkehr (Breite * Höhe); 
      }
   }
   Klasse Dreieck: Form
   {
      public Triangle (int a = 0, int b = 0): Basis (a, b)
      {
      
      }
      public override int Bereich ()
      {
         Console.WriteLine ( "Triangle-Klasse-Bereich:");
         Rückkehr (Breite * Höhe / 2); 
      }
   }
   Klasse Caller
   {
      public void CallArea (Shape sh)
      {
         int a;
         a = sh.area ();
         Console.WriteLine ( "Größe: {0}", a);
      }
   }  
   Klasse Tester
   {
      
      static void Main (string [] args)
      {
         Anrufer c = new Caller ();
         Rectangle r = new Rectangle (10, 7);
         Dreieck t = new Dreieck (10, 5);
         c.CallArea (r);
         c.CallArea (t);
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Rectangle-Klasse Größe:
Fläche: 70
Klasse Dreieck:
Fläche: 25