[C#-Tutorial] C#-Polymorphismus

C#-Polymorphismus

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

Polymorphismus kann statisch oder dynamisch sein. Beim statischen Polymorphismus erfolgt die Antwort der Funktion zur Kompilierungszeit. Beim dynamischen Polymorphismus erfolgt die Reaktion einer Funktion zur Laufzeit.

Statischer Polymorphismus

Zur Kompilierungszeit wird der Verbindungsmechanismus von Funktionen und Objekten als frühe Bindung bezeichnet, auch als statische Bindung bezeichnet. C# bietet zwei Techniken zum Implementieren des statischen Polymorphismus. Dies sind:

Funktionsüberladung

Operatorüberladung

Operatorüberladung wird im nächsten Kapitel besprochen, und dann werden wir die Funktionsüberladung besprechen.

Funktionsüberladung

Sie können mehrere Definitionen desselben Funktionsnamens im selben Bereich haben. Funktionsdefinitionen müssen sich voneinander unterscheiden, entweder durch die Art der Parameter in der Parameterliste oder durch die Anzahl der Parameter. Funktionsdeklarationen, die sich nur im Rückgabetyp unterscheiden, können nicht überladen werden.

Das folgende Beispiel zeigt mehrere identische Funktionen print(), die zum Drucken verschiedener Datentypen verwendet werden:

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

Wenn der obige Code kompiliert und ausgeführt wird, werden die folgenden Ergebnisse generiert:

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

Dynamischer Polymorphismus

C# ermöglicht Ihnen die Verwendung des Schlüsselworts abstract, um abstrakte Klassen zu erstellen, die Implementierungen von Teilklassen einer Schnittstelle bereitstellen. Die Implementierung ist abgeschlossen, wenn eine abgeleitete Klasse von dieser abstrakten Klasse erbt. Abstrakte Klassen enthalten abstrakte Methoden, die durch abgeleitete Klassen implementiert werden können. Abgeleitete Klassen verfügen über speziellere Funktionen.

Bitte beachten Sie, dass es hier einige Regeln für abstrakte Klassen gibt:

Sie können keine Instanz einer abstrakten Klasse erstellen.

Sie können eine abstrakte Methode nicht außerhalb einer abstrakten Klasse deklarieren.

Eine Klasse kann als versiegelt deklariert werden, indem das Schlüsselwort seal vor die Klassendefinition gesetzt wird. Wenn eine Klasse als versiegelt deklariert wird, kann sie nicht vererbt werden. Abstrakte Klassen können nicht als versiegelt deklariert werden.

Das folgende Programm demonstriert eine abstrakte Klasse:

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

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

Rectangle 类的面积：
面积： 70

When When there Ist eine in einer Klasse definierte Funktion, die in einer geerbten Klasse implementiert werden muss, können virtuelle Methoden verwendet werden. Virtuelle Methoden werden mit dem Schlüsselwort virtual deklariert. Virtuelle Methoden können in verschiedenen geerbten Klassen unterschiedliche Implementierungen haben. Aufrufe virtueller Methoden erfolgen zur Laufzeit.

Dynamischer Polymorphismus wird durch abstrakte Klassen und virtuelle Methoden erreicht.

Das folgende Programm demonstriert dies:

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

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

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

Das ist es [C#-Tutorial ] C#-Polymorphismus-Inhalte, bitte beachten Sie die chinesische PHP-Website (www.php.cn) für weitere verwandte Inhalte!