Curso de Programação Orientada a Objetos – 2.5 Polimorfismo

2.5 Polimorfismo

O polimorfismo é um dos pilares fundamentais da Programação Orientada a Objetos (POO). Ele permite que métodos em classes derivadas tenham comportamentos diferentes, mesmo que compartilhem a mesma assinatura de métodos definidos na classe base. O polimorfismo é alcançado por meio de métodos virtuais e sobrescritos, utilizando as palavras-chave virtual e override em Delphi e Lazarus.

Para demonstrar o conceito, vamos expandir o exemplo das contas bancárias usado anteriormente. Implementaremos métodos que exibem informações específicas para cada tipo de conta, mostrando como o polimorfismo pode ser utilizado.

Exemplo Prático: Polimorfismo com Contas Bancárias

1. Classe Base (TContaBancaria):
   • Define um método ExibirDetalhes que será sobrescrito pelas classes derivadas.
2. Classes Derivadas (TContaPoupanca e TContaCorrente):
   • Cada classe fornece uma implementação específica para ExibirDetalhes.

Código da Classe Base TContaBancaria

unit ContaBancariaUnit;

interface

type
  TContaBancaria = class
  private
    FSaldo: Currency;
    FTitular: string;
  public
    constructor Create(Titular: string; SaldoInicial: Currency);
    procedure Depositar(Valor: Currency);
    function Sacar(Valor: Currency): Boolean;
    procedure ExibirDetalhes; virtual; // Método virtual para polimorfismo
    property Saldo: Currency read FSaldo;
    property Titular: string read FTitular;
  end;

implementation

uses
  SysUtils;

{ TContaBancaria }

constructor TContaBancaria.Create(Titular: string; SaldoInicial: Currency);
begin
  FTitular := Titular;
  FSaldo := SaldoInicial;
end;

procedure TContaBancaria.Depositar(Valor: Currency);
begin
  FSaldo := FSaldo + Valor;
end;

function TContaBancaria.Sacar(Valor: Currency): Boolean;
begin
  if Valor <= FSaldo then
  begin
    FSaldo := FSaldo - Valor;
    Result := True;
  end
  else
    Result := False;
end;

procedure TContaBancaria.ExibirDetalhes;
begin
  WriteLn('Titular: ', FTitular);
  WriteLn('Saldo Atual: ', FSaldo:0:2);
end;

end.

Código da Classe Derivada TContaPoupanca

unit ContaPoupancaUnit;

interface

uses
  ContaBancariaUnit;

type
  TContaPoupanca = class(TContaBancaria)
  private
    FTaxaJuros: Double;
  public
    constructor Create(Titular: string; SaldoInicial: Currency; TaxaJuros: Double);
    procedure AplicarJuros;
    procedure ExibirDetalhes; override; // Sobrescrevendo o método virtual
  end;

implementation

{ TContaPoupanca }

constructor TContaPoupanca.Create(Titular: string; SaldoInicial: Currency; TaxaJuros: Double);
begin
  inherited Create(Titular, SaldoInicial);
  FTaxaJuros := TaxaJuros;
end;

procedure TContaPoupanca.AplicarJuros;
begin
  Depositar(Saldo * FTaxaJuros);
end;

procedure TContaPoupanca.ExibirDetalhes;
begin
  inherited;
  WriteLn('Tipo de Conta: Poupança');
  WriteLn('Taxa de Juros: ', FTaxaJuros * 100:0:2, '%');
end;

end.

Código da Classe Derivada TContaCorrente

unit ContaCorrenteUnit;

interface

uses
  ContaBancariaUnit;

type
  TContaCorrente = class(TContaBancaria)
  private
    FTaxaManutencao: Currency;
  public
    constructor Create(Titular: string; SaldoInicial: Currency; TaxaManutencao: Currency);
    procedure CobrarManutencao;
    procedure ExibirDetalhes; override; // Sobrescrevendo o método virtual
  end;

implementation

{ TContaCorrente }

constructor TContaCorrente.Create(Titular: string; SaldoInicial: Currency; TaxaManutencao: Currency);
begin
  inherited Create(Titular, SaldoInicial);
  FTaxaManutencao := TaxaManutencao;
end;

procedure TContaCorrente.CobrarManutencao;
begin
  Sacar(FTaxaManutencao);
end;

procedure TContaCorrente.ExibirDetalhes;
begin
  inherited;
  WriteLn('Tipo de Conta: Corrente');
  WriteLn('Taxa de Manutenção: ', FTaxaManutencao:0:2);
end;

end.

Exemplo de Uso do Polimorfismo

Agora, criamos um programa que utiliza o polimorfismo para exibir os detalhes de diferentes tipos de contas.

program ExemploPolimorfismo;

uses
  ContaBancariaUnit, ContaPoupancaUnit, ContaCorrenteUnit;

var
  Conta: TContaBancaria;
  Contas: array[1..2] of TContaBancaria;

begin
  // Criando uma conta poupança
  Contas[1] := TContaPoupanca.Create('Alice', 1000.00, 0.02);
  TContaPoupanca(Contas[1]).AplicarJuros;

  // Criando uma conta corrente
  Contas[2] := TContaCorrente.Create('Bob', 500.00, 15.00);
  TContaCorrente(Contas[2]).CobrarManutencao;

  // Exibindo detalhes de cada conta (polimorfismo em ação)
  for Conta in Contas do
  begin
    Conta.ExibirDetalhes;
    WriteLn('---');
  end;

  // Liberando memória
  for Conta in Contas do
    Conta.Free;
end.

Explicação

1. Método Virtual:
   • ExibirDetalhes é declarado como virtual na classe base para permitir que as classes derivadas o sobrescrevam.
2. Sobrescrita:
   • As classes TContaPoupanca e TContaCorrente implementam suas próprias versões de ExibirDetalhes usando a palavra-chave override.
3. Polimorfismo em Ação:
   • No programa principal, o método ExibirDetalhes é chamado para objetos de diferentes tipos (TContaPoupanca e TContaCorrente), mas o comportamento correto é definido em tempo de execução.

Conclusão

O polimorfismo simplifica a implementação de soluções escaláveis, permitindo tratar diferentes tipos de objetos de maneira uniforme. Em Delphi e Lazarus, o uso de métodos virtuais e sobrescritos é essencial para explorar todo o potencial dessa poderosa característica da POO.