С# — полиморфизм

Слово полиморфизм означает наличие множества форм. В парадигме объектно-ориентированного программирования полиморфизм часто выражается как «один интерфейс, несколько функций».

Полиморфизм может быть статическим или динамическим. В статическом полиморфизме , ответ функции определяется во время компиляции. В динамическом полиморфизме , это решается во время выполнения.

Статический полиморфизм

Механизм связывания функции с объектом во время компиляции называется ранним связыванием. Его также называют статическим связыванием. C# предоставляет два метода реализации статического полиморфизма. Они —

• Перегрузка функций
• Перегрузка оператора

Мы обсудим перегрузку операторов в следующей главе.

Перегрузка функции

У вас может быть несколько определений для одного и того же имени функции в одной и той же области. Определение функции должно отличаться друг от друга типами и/или количеством аргументов в списке аргументов. Вы не можете перегружать объявления функций, которые отличаются только типом возвращаемого значения.

В следующем примере показано использование функции print(). для печати разных типов данных —

Живая демонстрация

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

Когда приведенный выше код скомпилирован и выполнен, он дает следующий результат —

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

Динамический полиморфизм

C# позволяет создавать абстрактные классы, которые используются для реализации частичного класса интерфейса. Реализация завершается, когда производный класс наследуется от него. Аннотация классы содержат абстрактные методы, которые реализуются производным классом. Производные классы имеют более специализированную функциональность.

Вот правила об абстрактных классах —

• Вы не можете создать экземпляр абстрактного класса

• Вы не можете объявить абстрактный метод вне абстрактного класса

• Когда класс объявлен запечатанным , он не может быть унаследован, абстрактные классы не могут быть объявлены запечатанными.

Следующая программа демонстрирует абстрактный класс —

Живая демонстрация

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

Когда приведенный выше код скомпилирован и выполнен, он дает следующий результат —

Rectangle class area :
Area: 70

Когда у вас есть функция, определенная в классе, которую вы хотите реализовать в унаследованном(ых) классе(ах), вы используете виртуальный функции. Виртуальные функции могут быть реализованы по-разному в разных унаследованных классах, и решение о вызове этих функций будет приниматься во время выполнения.

Динамический полиморфизм реализуется с помощью абстрактных классов. и виртуальные функции .

Следующая программа демонстрирует это —

Живая демонстрация

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

Когда приведенный выше код скомпилирован и выполнен, он дает следующий результат —

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