C# - Polimorfismo

A palavra polimorfismo significa ter muitas formas. No paradigma de programação orientada a objetos, o polimorfismo é frequentemente expresso como 'uma interface, múltiplas funções'.

O polimorfismo pode ser estático ou dinâmico. Em polimorfismo estático , a resposta a uma função é determinada em tempo de compilação. Em polimorfismo dinâmico , é decidido em tempo de execução.

Polimorfismo Estático

O mecanismo de vincular uma função a um objeto durante o tempo de compilação é chamado de ligação antecipada. Também é chamado de ligação estática. C# fornece duas técnicas para implementar polimorfismo estático. Eles são -

• Sobrecarga de funções
• Sobrecarga do operador

Discutiremos a sobrecarga de operadores no próximo capítulo.

Sobrecarga de funções

Você pode ter várias definições para o mesmo nome de função no mesmo escopo. A definição da função deve diferir entre si pelos tipos e/ou pelo número de argumentos na lista de argumentos. Você não pode sobrecarregar declarações de função que diferem apenas pelo tipo de retorno.

O exemplo a seguir mostra o uso da função print() para imprimir diferentes tipos de dados -
Demonstração ao vivo

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

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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

Polimorfismo Dinâmico

C# permite que você crie classes abstratas que são usadas para fornecer implementação de classe parcial de uma interface. A implementação é concluída quando uma classe derivada herda dela. Resumo classes contêm métodos abstratos, que são implementados pela classe derivada. As classes derivadas possuem funcionalidades mais especializadas.

Aqui estão as regras sobre classes abstratas -

• 
  Você não pode criar uma instância de uma classe abstrata
  
• 
  Você não pode declarar um método abstrato fora de uma classe abstrata
  
• 
  Quando uma classe é declarada selada , não pode ser herdado, classes abstratas não podem ser declaradas seladas.
  

O programa a seguir demonstra uma classe abstrata -
Demonstração ao vivo

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

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Rectangle class area :
Area: 70

Quando você tem uma função definida em uma classe que deseja implementar em uma(s) classe(s) herdada(s), você usa virtual funções. As funções virtuais podem ser implementadas de forma diferente em diferentes classes herdadas e a chamada para essas funções será decidida em tempo de execução.

O polimorfismo dinâmico é implementado por classes abstratas e funções virtuais .

O programa a seguir demonstra isso -
Demonstração ao vivo

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

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

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