C# - Polymorphismus

Das Wort Polymorphismus bedeutet, viele Formen zu haben. Im objektorientierten Programmierparadigma wird Polymorphismus oft als „eine Schnittstelle, mehrere Funktionen“ ausgedrückt.

Polymorphismus kann statisch oder dynamisch sein. Im statischen Polymorphismus , wird die Antwort auf eine Funktion zur Kompilierzeit bestimmt. Im dynamischen Polymorphismus , wird zur Laufzeit entschieden.

Statischer Polymorphismus

Der Mechanismus zum Verknüpfen einer Funktion mit einem Objekt während der Kompilierzeit wird als frühe Bindung bezeichnet. Dies wird auch als statische Bindung bezeichnet. C# bietet zwei Techniken zum Implementieren von statischem Polymorphismus. Sie sind −

• Funktionsüberladung
• Operatorüberladung

Wir besprechen das Überladen von Operatoren im nächsten Kapitel.

Funktionsüberladung

Sie können mehrere Definitionen für denselben Funktionsnamen im selben Bereich haben. Die Definition der Funktion muss sich durch die Typen und/oder die Anzahl der Argumente in der Argumentliste voneinander unterscheiden. Sie können keine Funktionsdeklarationen überladen, die sich nur durch den Rückgabetyp unterscheiden.

Das folgende Beispiel zeigt die Verwendung der Funktion print() um verschiedene Datentypen zu drucken −

Live-Demo

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();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

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

Dynamischer Polymorphismus

Mit C# können Sie abstrakte Klassen erstellen, die verwendet werden, um eine partielle Klassenimplementierung einer Schnittstelle bereitzustellen. Die Implementierung ist abgeschlossen, wenn eine abgeleitete Klasse davon erbt. Zusammenfassung Klassen enthalten abstrakte Methoden, die von der abgeleiteten Klasse implementiert werden. Die abgeleiteten Klassen haben speziellere Funktionen.

Hier sind die Regeln für abstrakte Klassen −

• Sie können keine Instanz einer abstrakten Klasse erstellen

• Sie können keine abstrakte Methode außerhalb einer abstrakten Klasse deklarieren

• Wenn eine Klasse als versiegelt deklariert wird , es kann nicht vererbt werden, abstrakte Klassen können nicht als versiegelt deklariert werden.

Das folgende Programm demonstriert eine abstrakte Klasse −

Live-Demo

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();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Rectangle class area :
Area: 70

Wenn Sie eine Funktion in einer Klasse definiert haben, die Sie in einer oder mehreren geerbten Klassen implementieren möchten, verwenden Sie virtuell Funktionen. Die virtuellen Funktionen könnten in verschiedenen geerbten Klassen unterschiedlich implementiert werden und der Aufruf dieser Funktionen wird zur Laufzeit entschieden.

Dynamischer Polymorphismus wird durch abstrakte Klassen implementiert und virtuelle Funktionen .

Das folgende Programm demonstriert dies −

Live-Demo

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();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Rectangle class area:
Area: 70
Triangle class area:
Area: 25