Como usar o polimorfismo em C#
Índice
- O que é polimorfismo em C#
- Tipos de polimorfismo em C#
- Sobrecarga de método
- Método substituindo
- Exemplos de polimorfismo em C#
- Como usar o polimorfismo em C#
- Conclusão
O que é polimorfismo em C#
O polimorfismo vem de duas palavras gregas: poli e Morph. A palavra poli Aqui significa muitos, e Morph significa formas. É a capacidade do objeto na programação de adquirir diferentes formas.
O polimorfismo permite o tratamento de objetos de classes distintas como se fossem da mesma classe. Isso pode ser feito usando o conceito de herança, pois permite que classes derivadas tomem ou herdem as propriedades da classe base.
Tipos de polimorfismo em C#
O polimorfismo pode ser classificado em dois tipos com base em quando ocorre:
- Time de compilação [sobrecarga do método]
- Tempo de execução [substituição do método]
Sobrecarga de método
A sobrecarga do método pode definir vários métodos com o mesmo nome, mas contendo parâmetros diferentes. O compilador decide o método que será chamado com base em argumentos dados ao método. Usando a sobrecarga do método, podemos realizar tarefas semelhantes, mas com parâmetros de entrada diferentes.
Método substituindo
Método A substituição em C# é uma técnica que permite que uma classe derivada forneça sua própria implementação de um método que já é fornecido por sua classe base. A substituição do método é como a função virtual de C++. Quando um método em uma classe derivada tem o mesmo nome, o mesmo tipo de retorno e os mesmos parâmetros que um método em sua classe base, diz -se que o método da classe derivada substitui o método na classe base.
No polimorfismo, o método de base substituído deve ser virtual, abstrato ou substituir. Os métodos de substituição implementam os membros da classe base existentes de uma nova maneira. A substituição do método é alcançada usando as palavras -chave virtuais e substituídas.
Exemplos de polimorfismo em C#
Abaixo, é dado um código de exemplo que explica os dois métodos que substituem e sobrecarregam em C#:
Exemplo 1: sobrecarga de método
Aqui, no exemplo abaixo, definimos vários métodos em uma única classe. Todos esses métodos compartilham o mesmo nome, mas contêm parâmetros diferentes.
usando o sistema;programa de classe
void calculatesum (int num1, int num2)
Console.WriteLine ($ "A soma de num1 e num2 é num1 + num2");
Void calculatesum (Num1 duplo, Num2 duplo)
Console.WriteLine ($ "A soma de num1 e num2 é num1 + num2");
estático void main (string [] args)
Programa de programa = novo programa ();
int intnum1 = 1;
int intnum2 = 2;
duplo dublenum1 = 12.5;
duplo dublenum2 = 7.5;
programa.Calculatesum (intnum1, intnum2);
programa.Calculatesum (Doublenum1, Doublenum2);
O código acima fornece dois números para resumir, e demonstra sobrecarga de método em C#. O Calculetatesum O método está sobrecarregado para aceitar dois parâmetros inteiros e dois parâmetros duplos, respectivamente.
O método principal cria uma instância da classe do programa e chama o método Calculeatesum duas vezes, uma vez com dois argumentos inteiros e uma vez com dois argumentos duplos.
Quando o programa é executado, ele imprime a soma dos dois números passados para o Calculetatesum Método usando interpolação da string para criar a mensagem de saída. A saída a seguir pode ser vista no console:
Exemplo 2: substituição do método
Este exemplo demonstra o conceito de substituição do método, onde uma classe derivada pode fornecer sua própria implementação de um método herdado de sua classe base.
usando o sistema;forma de classe pública
Draw Public Virtual Void ()
Console.WriteLine ("desenhando uma forma");
Retângulo de classe pública: forma
Substituição pública Draw Void ()
Console.WriteLine ("desenhando um retângulo");
Programa de classe pública
public static void main (string [] args)
Forma da forma = nova forma ();
forma.Empate();
Retângulo retângulo = novo retângulo ();
retângulo.Empate();
Aqui está uma classe base que é nomeada Classe de forma. A classe de forma contém um método virtual chamado Empate. Aqui, uma palavra -chave virtual é uma indicação de que uma classe derivada pode substituir o método definido.
A classe de retângulo substitui o Empate método e é derivado da classe de forma. A classe retângulo tem seu próprio conjunto de propriedades para implementação. Nesse caso, o método de desenho de impressões de classe de retângulo Desenhando um retângulo em vez de Desenhando uma forma.
Em seguida, em Principal(), Uma instância da classe de forma é criada e seu método de desenho é chamado. Então uma instância da classe Retângulo é criada e seu método de desenho é chamado.
Como a classe de retângulo substitui o método de desenho da classe de forma, quando chamamos o método de desenho no objeto retângulo, a implementação da classe retângulo é chamada e Desenhando um retângulo é impresso no console. Quando o programa for executado, ele será lançado:
Como usar o polimorfismo em C#
Depois de conhecer o conceito de polimorfismo em C#, agora abordaremos as etapas para usá -lo na programação C#.
Etapa 1: Defina a classe base
O primeiro passo é definir a classe base que contém os métodos ou propriedades que serão compartilhados por todas as classes derivadas. A classe base é definida usando o aula Palavra -chave:
animal de classe públicaPublic Virtual Void Makeound ()
Console.WriteLine ("O animal faz um som");
O código acima contém uma classe base Animal que tem um método virtual Fazer som. A palavra -chave virtual mostra que a classe derivada substituirá o método definido.
Etapa 2: Defina as classes derivadas
O próximo passo é definir as classes derivadas que vêm da classe base. Em C#, podemos definir uma classe derivada usando o ":" operador.
Cão de classe pública: animalSubstituição pública Void Makeound ()
Console.WriteLine ("The Dog Barks");
Cat de classe pública: animal
Substituição pública Void Makeound ()
Console.WriteLine ("The Cat Meows");
O exemplo acima contém duas classes de acionamento Cachorro e Gato, E ambas as classes fazem propriedades da classe base que se chama Animal. Ambas as classes substituem o Fazer som método com sua implementação.
Etapa 3: Use o polimorfismo
A etapa final é usar o polimorfismo no código. Agora definiremos instâncias das classes derivadas e chamaremos seus métodos usando a referência da classe base.
Animal myanimal = novo animal ();Animal myDog = new Dog ();
Animal mycat = novo gato ();
Myanimal.Fazer som();
meu cachorro.Fazer som();
meu gato.Fazer som();
Aqui criamos instâncias das aulas de animais, cães e gatos. Depois disso, o Fazer som O método é chamado em cada instância. Desde o Fazer som O método é virtual, a implementação real chamada depende do tipo real da instância. Isso significa que quando chamamos o MyDog.Makeound () ou mycat.Makeound (), o Fazer som o método será chamado na classe de cães ou gatos, respectivamente.
Código de exemplo
A seguir, o código combinado das etapas acima explicadas:
usando o sistema;animal de classe pública
Public Virtual Void Makeound ()
Console.WriteLine ("O animal faz um som");
Cão de classe pública: animal
Substituição pública Void Makeound ()
Console.WriteLine ("The Dog Barks");
Cat de classe pública: animal
Substituição pública Void Makeound ()
Console.WriteLine ("The Cat Meows");
Programa de classe pública
public static void main ()
Animal myanimal = novo animal ();
Animal myDog = new Dog ();
Animal mycat = novo gato ();
Myanimal.Fazer som();
meu cachorro.Fazer som();
meu gato.Fazer som();
Depois de executar o código acima, a seguinte saída pode ser vista no console:
Conclusão
Usando o polimorfismo em C# Um código pode ser escrito que gerencia vários tipos de objetos. Em C#, podemos usar o polimorfismo definindo uma classe base, criando classes derivadas que herdam da classe base e usando a referência da classe base para chamar os métodos das classes derivadas. Seguindo as etapas descritas no artigo acima, qualquer pessoa pode usar o conceito de polimorfismo em C#.