Introdução ao polimorfismo em C #
O polimorfismo é um dos princípios da programação orientada a objetos. Poli significa múltiplo e morphing significa passar por uma transformação; polimorfismo significa a capacidade de assumir múltiplas formas.
A saída dos operadores varia dependendo dos tipos dos operandos, que é uma forma de polimorfismo conhecida como Sobrecarga do operador. Aqui, o operador pode assumir várias formas para produzir diferentes resultados. A saída das funções varia com base em diferentes tipos e parâmetros de retorno, que é outra forma de polimorfismo conhecido como Sobrecarga de funções. Aqui, a função assume várias formas para produzir várias saídas.
O polimorfismo é usado extensivamente para implementar a herança. Objetos com estrutura interna diferente podem implementar uma interface comum por meio de polimorfismo. O diagrama a seguir ilustra o funcionamento do polimorfismo:
Esta figura explica que a argila é o objeto pai a partir do qual os objetos de panela, tigela e brinquedo são feitos. Todos esses objetos são diferentes, mas têm propriedades de argila. Esses três objetos têm formas diferentes e são usados de maneiras diferentes, mesmo quando são feitos do mesmo material argila.
Formas de polimorfismo
Abaixo estão as duas formas de polimorfismo:
1. Sobrecarga do Operador
Um Operador pode fornecer diferentes saídas com base no tipo de operando em que está operando. Isso é chamado de Sobrecarga do operador. Por exemplo, o operador '+' pode executar adição em dois números inteiros, enquanto pode concatenar duas cadeias. Assim, o mesmo operador pode ser usado de 2 maneiras diferentes. O operador de adição geralmente adiciona dois números. No entanto, no caso de números complexos, a adição é um pouco diferente, onde as partes reais e imaginárias correspondentes são adicionadas separadamente. Aqui está um código de exemplo que mostra como o operador '+' pode ser sobrecarregado para adicionar números complexos:
Código:
using System;
namespace Overload (
class Complex
(
public double x;
public double y;
// no-argument constructor
public Complex() ()
// parameterized constructor
public Complex(double real, double img)
(
x = real;
y = img;
)
// Overloading of Binary "+" operator
public static Complex operator + (Complex c1,
Complex c2)
(
Complex c3 = new Complex();
c3.x = c1.x + c2.x;
c3.y = c1.y + c2.y;
return c3;
)
// function to display result
public void display()
(
Console.WriteLine("(0) + (1)i", x, y);
)
)
class CalNum (
// Driver Code
static void Main(string() args)
(
Complex num1 = new Complex(2.5, 3.5);
Complex num2 = new Complex(1.2, 6.5);
Complex num3 = num1 + num2;
Console.Write("c1 = ");
num1.display();
Console.Write("c2 = ");
num2.display();
Console.Write("c3 = ");
num3.display();
)
)
)
Resultado:
Esta saída ilustra a sobrecarga do operador para adicionar dois números complexos. O código mostra a sobrecarga do operador, bem como a sobrecarga de funções.
2. Sobrecarga de Função
Uma função pode fornecer saídas diferentes com base no número de parâmetros, bem como em seus tipos de retorno e no tipo de retorno da função. O código acima mencionado também cobre a sobrecarga de função usando um construtor. Existem 2 construtores no código; um é o construtor padrão que é deixado vazio enquanto o outro é um construtor parametrizado que é usado para inicializar o número complexo com os valores mencionados como parâmetros.
Tomando o exemplo ilustrado na figura, a função é moldar a argila e a direção do curso é o membro fornecido para moldar a argila. Com base em diferentes direções do curso, o barro é transformado em panela, tigela e brinquedo, respectivamente.
Código:
using System;
using System.Collections.Generic;
public class Clay
(
// A few example members
public int Height ( get; set; )
public int strokeDirection ( get; set; )
// Virtual method
public virtual void Mould()
(
Console.WriteLine("Beginning to mould the clay");
)
)
class Pot : Clay
(
public override void Mould()
(
// Code to make a pot Console.WriteLine("Making a pot");
base.Mould();
)
)
class Bowl : Clay
(
public override void Mould()
(
// Code to make a bowl
Console.WriteLine("Making a bowl");
base.Mould();
)
)
class Toy : Clay
(
public override void Mould()
(
// Code to make a toy
Console.WriteLine("Making a toy");
base.Mould();
)
)
class Program
(
static void Main(string() args)
(
// Illustrating Polymorphism #1: a Pot, Bowl and Toy
// can all be used wherever Clay is expected. No cast is
// needed because an implicit conversion exists from a derived
// class to its base class.
var items = new List
(
new Pot(),
new Bowl(),
new Toy()
);
// Polymorphism at work #2: the virtual method Mould is
// invoked on each of the derived classes, not the base class.
foreach (var item in items)
(
item.Mould();
)
)
)
Resultado:
Como você deve ter notado no código, classe clay é a classe pai cujas classes filho são classes pote, brinquedo e tigela. O método 'Mold' é definido na classe pai e na classe filho com a mesma assinatura de função. Portanto, quando um objeto da classe filho é criado e chama o método Mold, o método da classe base é substituído pelo método da classe filho. Assim, vemos a saída do método da classe filho. O código acima mostra a substituição do método e não a sobrecarga para ilustrar o polimorfismo.
Pontos a serem lembrados para o polimorfismo em c #
- A sobrecarga é diferente de Substituir. A sobrecarga possui assinaturas de funções diferentes, enquanto a substituição tem as mesmas assinaturas de funções
- Polimorfismo refere-se à alteração do comportamento de uma superclasse na subclasse.
- Herança refere-se ao uso da estrutura e comportamento de uma superclasse em uma subclasse.
A seguir, são apresentados alguns dos principais argumentos:
- O polimorfismo é um dos principais paradigmas da programação orientada a objetos.
- A sobrecarga de função modifica a função de acordo com os tipos e parâmetros de retorno da função na classe herdada.
- A sobrecarga do operador modifica a definição do operador conforme os parâmetros fornecidos.
- O polimorfismo é usado para implementá-lo e decide em tempo de execução chamar o método de classe filho usando a substituição de método.
Artigos recomendados
Este é um guia para o polimorfismo em C #. Aqui discutimos as duas formas de polimorfismo em C #, ou seja, sobrecarga de operador e sobrecarga de função com código de exemplo. Você também pode consultar o seguinte artigo para saber mais -
- O que é StringBuilder em C #
- Copiar Construtor em C #
- O que é multithreading em c #?
- O que é Design Pattern em C #?
- Tipos de construtor em C # com implementação de código
- Guia completo para multithreading em c #