Classes Abstratas e Polimorfismo

Classes Abstratas

São classes que NÃO PODEM SER INSTANCIADAS e que apenas servem de base para o desenvolvimento de outras classes. Uma classe abstrata é comumente utilizada quando temos situação de herança. Da mesma forma, também temos Métodos Abstratos, que são aqueles que não podem ser acessados sem que sejam reescritos pela classe que os herdam. Vejamos o exemplo:

abstract class Forma { private double _area; private string _cor; private double _perimetro; public string Cor { get { return _cor; } set {  _cor = value; } } public double Area { get {return _area;} set {_area = value;} } public double Perimetro { get {return _perimetro;} set

{ _perimetro = value; } } public abstract void CalcularArea(); public abstract void CalcularPerimetro(); public string Descricao() { return "Sou a classe abstrata Forma."; } }

class Quadrado : Forma { private double lado; public double Lado { get {return lado;} set {lado = value;} } public override void CalcularArea() { this.Area = lado * lado; } public override void CalcularPerimetro() { this.Perimetro = 4 * lado; } }

class Program { static void Main(string[] args) { Quadrado q = new Quadrado();

Console.WriteLine(q.Descricao()); Console.WriteLine("Informe o valor do lado do quadrado em metros."); q.Lado = Convert.ToInt32(Console.ReadLine()); q.CalcularArea(); q.CalcularPerimetro(); Console.WriteLine("A área do quadrado é : " + q.Area + " m2 "); Console.WriteLine("O perímetro do quadrado é : " + q.Perimetro + " m "); Console.ReadKey(); } }

Acima, temos a classe Forma que é abstrata e que por sua vez não pode ser instanciada. No entanto, um quadrado, triângulo ou um losango são formas e herdam características desta classe. Ela por si só não tem sentido funcional nenhum no projeto e por isso deve ser declarada como abstrata, pois apenas serve de modelo para a construção das subclasses que constroem as formas geométricas.

Polimorfismo

Polimorfismo é o princípio pelo qual duas ou mais classes derivadas de uma mesma superclasse podem invocar métodos que têm a mesma identificação (assinatura) mas comportamentos distintos, especializados para cada classe derivada, usando para tanto uma referência a um objeto do tipo da superclasse" Usando polimorfismo podemos: 1. Invocar métodos da classe derivada através da classe base em tempo de execução; 2. Permitir que classes forneçam diferentes implementações de métodos que são chamados com o mesmo nome; Polimorfismo por sobrescrita e por sobrecarga Polimorfismo por sobrescrita ocorre quando temos um método abstrato ou virtual que podem ser reescritos com comportamentos diferentes em cada subclasse que ele está presente. Método Virtual -> parecido com o método abstrato, porém, além de permitir a sobrescrita ele também pode ser invocado. Ex.:

public class Veiculo { private string tipo;

public string Tipo { get { return tipo; } set { tipo = value; } } public Veiculo(string tipoVeiculo) { this.tipo = tipoVeiculo; } public virtual void Mover() {} public virtual void Parar() {} } public class Automovel : Veiculo { public Automovel(string tipoVeiculo) : base(tipoVeiculo) {} public override void Mover() { Console.WriteLine("Acelerando o veículo"); } public override void Parar() { Console.WriteLine("Estou brecando o veículo."); } } public class Aeronave : Veiculo { public Aeronave(string tipoVeiculo) : base(tipoVeiculo) {} public override void Mover() { Console.WriteLine("Decolando a aeronave"); } public override void Parar() { Console.WriteLine("Estou aterrisando a aeronave."); } }

 class Program { static void Main(string[] args) { Veiculo[] veiculo = new Veiculo[2]; veiculo[0] = new Automovel("Ferrari"); veiculo[1] = new Aeronave("Tucano"); MovimentarVeiculo(veiculo[0]); MovimentarVeiculo(veiculo[1]); Console.ReadKey();

} public static void MovimentarVeiculo(Veiculo veiculo) { Console.WriteLine(veiculo.Tipo); veiculo.Mover(); } }

Polimorfismo por sobrecarga ocorre quando temos métodos com a mesma assinatura, porém, com parametrização diferente. Vejamos o exemplo abaixo:

class Calcular { public int Soma(int num1, int num2) { return (num1 + num2); } public int Soma(int num1, int num2, int num3) { return (num1 + num2 + num3); } }

class Program {

static void Main(string[] args) { Calcular calc = new Calcular(); Console.WriteLine("\nPolimorfismo com sobrecarga\n"); Console.WriteLine("Somando 2 números..."); Console.WriteLine(calc.Soma(45,43)); Console.WriteLine("Somando 3 números..."); Console.WriteLine(calc.Soma(45, 43, 100 )); Console.ReadKey(); } }

O método soma é utilizado 2 vezes na classe Calcular, porém, cada um desses métodos tem um número diferentes de parâmetros de entrada. D esta forma, ele trabalha com polimorfismo por sobrecarga.