Curso de Programação Orientada a Objetos – 2.4 Herança

 

A herança é um dos pilares fundamentais da Programação Orientada a Objetos (POO), permitindo que uma classe derive características (atributos e métodos) de outra. Com isso, podemos reutilizar código, criar hierarquias de classes e especializar funcionalidades. Em Delphi e Lazarus, a herança é implementada utilizando a palavra-chave class e o operador de herança = seguido da classe da qual a nova classe herdará.

 

Vamos criar um exemplo prático com classes de contas bancárias, onde TContaBancaria será a classe base, e TContaPoupanca e TContaCorrente serão classes derivadas.

 

Exemplo Prático: Classes TContaBancaria, TContaPoupanca e TContaCorrente

• Classe Base (TContaBancaria): Contém atributos e métodos básicos de uma conta bancária.
• Classe Derivada (TContaPoupanca): Representa uma conta poupança que adiciona juros sobre o saldo.
• Classe Derivada (TContaCorrente): Representa uma conta corrente que possui uma tarifa de manutenção.

 

Código da Classe Base TContaBancaria

unit ContaBancariaUnit;

interface

type
  TContaBancaria = class
  private
    FSaldo: Currency;
    FTitular: string;
  protected
    procedure SetSaldo(Valor: Currency);
  public
    constructor Create(Titular: string; SaldoInicial: Currency);
    procedure Depositar(Valor: Currency);
    function Sacar(Valor: Currency): Boolean;
    procedure ExibirSaldo;
    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;
  SetSaldo(SaldoInicial);
end;

procedure TContaBancaria.SetSaldo(Valor: Currency);
begin
  if Valor >= 0 then
    FSaldo := Valor
  else
    raise Exception.Create('Saldo não pode ser negativo.');
end;

procedure TContaBancaria.Depositar(Valor: Currency);
begin
  if Valor > 0 then
    SetSaldo(FSaldo + Valor)
  else
    raise Exception.Create('Valor de depósito inválido.');
end;

function TContaBancaria.Sacar(Valor: Currency): Boolean;
begin
  if (Valor > 0) and (Valor <= FSaldo) then
  begin
    SetSaldo(FSaldo - Valor);
    Result := True;
  end
  else
  begin
    Result := False;
    raise Exception.Create('Saldo insuficiente ou valor de saque inválido.');
  end;
end;

procedure TContaBancaria.ExibirSaldo;
begin
  WriteLn('Titular: ' + FTitular);
  WriteLn('Saldo Atual: ' + CurrToStr(FSaldo));
end;

end.

A classe TContaBancaria define métodos básicos de depósito, saque e exibição de saldo. Esse código serve como base para heranças futuras.

 

Classe Derivada TContaPoupanca

A TContaPoupanca herda de TContaBancaria e adiciona um método para aplicar juros ao saldo.

unit ContaPoupancaUnit;

interface

uses
  ContaBancariaUnit;

type
  TContaPoupanca = class(TContaBancaria)
  public
    procedure AplicarJuros(TaxaJuros: Double);
  end;

implementation

{ TContaPoupanca }

procedure TContaPoupanca.AplicarJuros(TaxaJuros: Double);
begin
  // Adiciona juros ao saldo
  SetSaldo(Saldo * (1 + TaxaJuros));
end;

end.

Aqui, a TContaPoupanca expande a funcionalidade básica da TContaBancaria com o método AplicarJuros, que adiciona um percentual de juros ao saldo.

 

Classe Derivada TContaCorrente

A TContaCorrente também herda de TContaBancaria, mas inclui uma tarifa de manutenção que é descontada do saldo.

unit ContaCorrenteUnit;

interface

uses
  ContaBancariaUnit;

type
  TContaCorrente = class(TContaBancaria)
  public
    procedure CobrarTarifa(Tarifa: Currency);
  end;

implementation

{ TContaCorrente }

procedure TContaCorrente.CobrarTarifa(Tarifa: Currency);
begin
  if Saldo >= Tarifa then
    SetSaldo(Saldo - Tarifa)
  else
    raise Exception.Create('Saldo insuficiente para a tarifa.');
end;

end.

A TContaCorrente adiciona o método CobrarTarifa, que reduz o saldo da conta com uma tarifa de manutenção, desde que haja saldo suficiente.

 

Exemplo de Uso das Classes TContaPoupanca e TContaCorrente

program ExemploHerancaContaBancaria;

uses
  SysUtils, ContaBancariaUnit, ContaPoupancaUnit, ContaCorrenteUnit;

var
  ContaPoupanca: TContaPoupanca;
  ContaCorrente: TContaCorrente;

begin
  // Criando uma conta poupança
  ContaPoupanca := TContaPoupanca.Create('Alice', 1000.00);
  ContaPoupanca.ExibirSaldo;
  ContaPoupanca.AplicarJuros(0.02); // 2% de juros
  ContaPoupanca.ExibirSaldo;

  // Criando uma conta corrente
  ContaCorrente := TContaCorrente.Create('Bob', 500.00);
  ContaCorrente.ExibirSaldo;
  ContaCorrente.CobrarTarifa(10.00); // Tarifa de manutenção de R$ 10,00
  ContaCorrente.ExibirSaldo;

  // Liberando memória
  ContaPoupanca.Free;
  ContaCorrente.Free;
end.

 

Explicação do Código

1. Instanciando TContaPoupanca:
   • Criamos um objeto ContaPoupanca e aplicamos juros de 2% ao saldo com o método AplicarJuros.
2. Instanciando TContaCorrente:
   • Criamos um objeto ContaCorrente e aplicamos uma tarifa de R$ 10,00 com o método CobrarTarifa.
3. Herança e Expansão de Funcionalidades:
   • Cada classe derivada (TContaPoupanca e TContaCorrente) herda os métodos e atributos da TContaBancaria e ainda adiciona novos métodos específicos, sem necessidade de duplicação de código.

 

Conclusão

A herança permite que classes derivadas especializem e expandam funcionalidades de uma classe base. No exemplo, TContaPoupanca e TContaCorrente herdam de TContaBancaria, mas cada uma adiciona funcionalidades únicas, como aplicar juros ou cobrar tarifas.

 

 

Continue o curso no próximo post!

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

 

 

#Herança #POO #ProgramaçãoOrientadaAObjetos #CursoDeProgramação

#ReutilizaçãoDeCódigo #DevIniciante #GiovaniDaCruz

#DesenvolvimentoDeSoftware #CompartilheConhecimento #AprendizadoTech

 #Delphi #Lazarus #Pascal