C# - Polymorfisme

Het woord polymorfisme betekent vele vormen hebben. In het objectgeoriënteerde programmeerparadigma wordt polymorfisme vaak uitgedrukt als 'één interface, meerdere functies'.

Polymorfisme kan statisch of dynamisch zijn. In statisch polymorfisme , wordt de respons op een functie bepaald tijdens het compileren. In dynamisch polymorfisme , wordt tijdens runtime besloten.

Statisch polymorfisme

Het mechanisme van het koppelen van een functie aan een object tijdens het compileren wordt vroege binding genoemd. Het wordt ook statische binding genoemd. C# biedt twee technieken om statisch polymorfisme te implementeren. Ze zijn −

• Functie overbelast
• Overbelasting operator

We bespreken overbelasting van de operator in het volgende hoofdstuk.

Functie overbelasting

U kunt meerdere definities hebben voor dezelfde functienaam in hetzelfde bereik. De definitie van de functie moet van elkaar verschillen door de typen en/of het aantal argumenten in de argumentenlijst. U kunt functiedeclaraties die alleen verschillen per retourtype niet overbelasten.

Het volgende voorbeeld toont het gebruik van de functie print() om verschillende gegevenstypes af te drukken −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

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

Dynamisch polymorfisme

Met C# kunt u abstracte klassen maken die worden gebruikt om een ​​gedeeltelijke klassenimplementatie van een interface te bieden. De implementatie is voltooid wanneer een afgeleide klasse ervan erft. Abstract klassen bevatten abstracte methoden, die worden geïmplementeerd door de afgeleide klasse. De afgeleide klassen hebben meer gespecialiseerde functionaliteit.

Hier zijn de regels over abstracte klassen −

• U kunt geen instantie van een abstracte klasse maken

• Je kunt een abstracte methode niet declareren buiten een abstracte klasse

• Wanneer een klas verzegeld wordt verklaard , het kan niet worden geërfd, abstracte klassen kunnen niet verzegeld worden verklaard.

Het volgende programma demonstreert een abstracte 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 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();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Rectangle class area :
Area: 70

Als je een functie hebt gedefinieerd in een klasse die je wilt implementeren in een overgeërfde klasse(n), gebruik je virtueel functies. De virtuele functies kunnen anders worden geïmplementeerd in verschillende geërfde klassen en de aanroep van deze functies zal tijdens runtime worden beslist.

Dynamisch polymorfisme wordt geïmplementeerd door abstracte klassen en virtuele functies .

Het volgende programma demonstreert dit −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

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