Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos) |
![]() |
Iremos entrar agora em nosso último tópico sobre POO, e muito interessante que é polimorfismo.Se você seguiu toda a trajetória do artigo sobre POO deve ter visto várias formas de polimorfismo (isso não foi um trocadilho) durante a leitura.
Vimos em: Herança (POO) Leia este artigo e depois do entendimento, volte a eles e tente identificar o uso do polimorfismo. Aqui iremos abordar o polimorfismo de uma forma mais ampla e detalhada. Então vamos lá. Polimorfismo Etimologicamente, polimorfismo quer dizer: 1 Que se apresenta ou ocorre sob formas diversas. Em orientação a objetos podemos dizer também que o objeto pode ter “vários comportamentos”. Quando você chama um método ele pode se referir a qualquer objeto, por exemplo o método “Abrir()”, ele pode abrir uma tampa de garrafa, uma janela, uma porta, pode abrir alguma coisa. Em polimorfismo é necessário que os métodos tenham a mesma assinatura, o mecanismo utilizado é o de redefinição de métodos (Overriding Definições – Intermediário (POO)) , não confundir com sobrecarga de métodos (Overload Definições – Intermediário (POO)). Em polimorfismo podemos: 1 Instanciar objetos diferentes para um mesmo tipo. Vamos à alguns exemplos para reforçarmos as idéias. Vamos criar nossas classes que servirão de base para todo o exemplo. Iremos criar uma calculadora bem simples, que implemente as quatro operações básicas. Classe Base namespace Polimorfismo { /// <summary> /// Classe base para efetuar os cálculos matemáticos /// </summary> abstract class CalculoMatematico { public virtual double Valor1 { get; set; } public virtual double Valor2 { get; set; } public abstract double Resultado(); } } Multiplicação namespace Polimorfismo { class Multiplicacao : CalculoMatematico { public override double Resultado() { return Valor1 * Valor2; } } } Divisão namespace Polimorfismo { class Divisao : CalculoMatematico { public override double Resultado() { return Valor1 / Valor2; } } } Adição namespace Polimorfismo { class Adicao : CalculoMatematico { public override double Resultado() { return Valor1 + Valor2; } } } Subtração namespace Polimorfismo { class Subtracao : CalculoMatematico { public override double Resultado() { return Valor1 - Valor2; } } } Vamos agora ao primeiro exemplo. namespace Polimorfismo { class Program { static void Main(string[] args) { //veja que definimos o tipo //como CalculoMatematico CalculoMatematico calc; //aqui é criado como Adicao calc = new Adicao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(calc.Resultado().ToString("N2")); //aqui é criado como Divisao calc = new Divisao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(calc.Resultado().ToString("N2")); //aqui é criado como Subtracao calc = new Subtracao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(calc.Resultado().ToString("N2")); //aqui é criado como Multiplicacao calc = new Multiplicacao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(calc.Resultado().ToString("N2")); Console.ReadKey(); } } } O nosso segundo item diz que podemos substituir condicionais com o uso de polimorfismo. Definição da classe Calculadora: namespace Polimorfismo { public enum TipoCalculo { Adicao, Subtracao, Multiplicacao, Divisao } static class Calculadora { /// <summary> /// Neste método temos que informar o tipo /// de calculo que o mesmo irá fazer /// </summary> /// <param name="tipo">tipo do calculo feito</param> /// <param name="valor1">valor 1 para o calculo </param> /// <param name="valor2">valor 2 para o calculo</param> /// <returns>resultado da expressão</returns> public static double Calcular(TipoCalculo tipo, double valor1, double valor2) { double resultado = 0; //e aqui temos o condicional switch switch (tipo) { case TipoCalculo.Adicao: resultado = valor1 + valor2; break; case TipoCalculo.Subtracao: resultado = valor1 - valor2; break; case TipoCalculo.Multiplicacao: resultado = valor1 * valor2; break; case TipoCalculo.Divisao: resultado = valor1 / valor2; break; default: throw new NotImplementedException("nunca poderá chegar aqui"); } return resultado; } /// <summary> /// fazendo deste modo não precisamos /// utilizar nenhum condicional /// </summary> /// <param name="calc">tipo de calculo</param> /// <returns>resultado do calculo</returns> public static double Calcular(CalculoMatematico calc) { return calc.Resultado(); } } } Exemplificando… namespace Polimorfismo { class Program { static void Main(string[] args) { //aqui vamos usar o condicional Console.WriteLine("Usando o Condicional"); Console.WriteLine(Calculadora.Calcular(TipoCalculo.Adicao, 23, 34).ToString("N2")); Console.WriteLine(Calculadora.Calcular(TipoCalculo.Divisao, 23, 34).ToString("N2")); Console.WriteLine(Calculadora.Calcular(TipoCalculo.Multiplicacao, 23, 34).ToString("N2")); Console.WriteLine(Calculadora.Calcular(TipoCalculo.Subtracao, 23, 34).ToString("N2")); Console.WriteLine("".PadLeft(80, '-')); Console.WriteLine("Usando polimorfismo"); //Aqui nao iremos usar o condicional. //substituiremos pelo uso do polimorfismo CalculoMatematico calc; //aqui é criado como Adicao calc = new Adicao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(Calculadora.Calcular(calc).ToString("N2")); //aqui é criado como Divisao calc = new Divisao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(Calculadora.Calcular(calc).ToString("N2")); //aqui é criado como Multiplicacao calc = new Multiplicacao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(Calculadora.Calcular(calc).ToString("N2")); //aqui é criado como Subtracao calc = new Subtracao(); calc.Valor1 = 23; calc.Valor2 = 34; Console.WriteLine(Calculadora.Calcular(calc).ToString("N2")); Console.ReadKey(); } } } Na classe Calculadora, além de exemplificarmos a substituição de um condicional com o uso do polimorfismo, ainda vimos a sobrecarga de métodos, temos dois métodos Calcular com assinaturas diferentes. Para um melhor entendimento de sobrecarga recomendo a leitura do tópico Definições – Intermediário (POO). E vimos também o item 3 que diz que podemos aceitar parâmetros de várias formas de objetos reparem que o método public static double Calcular(CalculoMatematico calc) aceitou os quatro tipos básicos. Conclusão Vimos o uso do polimorfismo em métodos, mas podemos usar a idéia em construtores, propriedades, no uso de Generics (Tipos Genéricos (Generics)), que podemos chamar de Polimorfismo Genérico. Podemos citar rapidamente o uso de downcast (converter em uma classe mais específica) , upcast (definir em uma classe mais genérica). namespace Polimorfismo { class Program { static void Main(string[] args) { //definir objeto CalculoMatematico calc = new Adicao(); calc.Valor1 = 22; calc.Valor2 = 33; //downcast (classe mais específica) Adicao adicao = (Adicao)calc; Console.WriteLine(adicao.Resultado()); //upcast (classe mais genérica) calc = (CalculoMatematico)adicao; Console.WriteLine(calc.Resultado()); Console.ReadKey(); } } } |
É isso ai pessoal 🙂
Até o próximo
♦ Marcelo