Curso de Programação Orientada a Objetos – 2.3 Encapsulamento

O encapsulamento é um dos pilares da Programação Orientada a Objetos (POO) e refere-se à prática de esconder os detalhes internos de uma classe, expondo apenas o que é necessário para o uso correto dos objetos.

Ele permite proteger os dados internos da classe contra manipulações externas indevidas e, ao mesmo tempo, fornece uma interface controlada para interagir com esses dados.

Em Delphi e Lazarus, o encapsulamento é implementado por meio de modificadores de acesso, como private, protected e public, que definem a visibilidade dos atributos e métodos de uma classe.

 

Exemplo Prático: Classe TContaBancaria com Encapsulamento

Vamos criar uma classe TContaBancaria que representa uma conta bancária. Nesta classe, os atributos Saldo e Titular serão encapsulados para controlar melhor o acesso e a manipulação desses dados.

unit ContaBancariaUnit;

interface

type
  TContaBancaria = class
  private
    FSaldo: Currency;
    FTitular: string;
    // Método privado que apenas a classe pode acessar
    procedure SetSaldo(Valor: Currency);
  public
    // Construtor
    constructor Create(Titular: string; SaldoInicial: Currency);
    // Métodos para manipular o saldo de forma controlada
    procedure Depositar(Valor: Currency);
    function Sacar(Valor: Currency): Boolean;
    procedure ExibirSaldo;
    // Propriedade de acesso ao saldo
    property Saldo: Currency read FSaldo;
    // Propriedade de acesso ao titular
    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.

No código acima:

• Atributos Privados:
  • FSaldo e FTitular são atributos privados, acessíveis somente dentro da classe TContaBancaria, garantindo que apenas métodos internos possam modificá-los diretamente.
• Método Privado SetSaldo:
  • SetSaldo é um método privado que ajusta o saldo da conta, garantindo que o saldo nunca seja negativo. Esse método é utilizado internamente para manipular o saldo de forma segura.
• Métodos Públicos:
  • Depositar e Sacar permitem adicionar e remover dinheiro da conta de maneira controlada.
  • ExibirSaldo exibe o saldo e o titular da conta.
• Propriedades Saldo e Titular:
  • A propriedade Saldo é de leitura, o que significa que o saldo pode ser lido de fora da classe, mas não pode ser modificado diretamente. Já a propriedade Titular permite acesso apenas ao nome do titular.

 

Exemplo de Uso da Classe TContaBancaria

Vamos instanciar um objeto da classe TContaBancaria e utilizar seus métodos para ver o encapsulamento em ação.

program ExemploContaBancaria;

uses
  SysUtils, ContaBancariaUnit;

var
  Conta: TContaBancaria;

begin
  // Criando uma nova conta bancária com saldo inicial
  Conta := TContaBancaria.Create('Carlos Silva', 500.00);

  // Exibindo saldo inicial
  Conta.ExibirSaldo;

  // Depositando dinheiro
  Conta.Depositar(150.00);
  Conta.ExibirSaldo;

  // Tentando sacar um valor válido
  if Conta.Sacar(200.00) then
    WriteLn('Saque realizado com sucesso.')
  else
    WriteLn('Falha no saque.');

  Conta.ExibirSaldo;

  // Tentando sacar um valor maior que o saldo disponível
  try
    Conta.Sacar(600.00);
  except
    on E: Exception do
      WriteLn('Erro: ' + E.Message);
  end;

  // Exibindo o saldo final
  Conta.ExibirSaldo;

  // Liberando a memória do objeto
  Conta.Free;
end.

 

Explicação do Código

1. Encapsulamento Protegido pelo Método SetSaldo:
   • SetSaldo verifica se o valor é maior ou igual a zero. Se tentarmos atribuir um valor negativo ao saldo, o método lança uma exceção.
2. Método de Depósito:
   • Depositar verifica se o valor é positivo antes de adicionar o valor ao saldo.
3. Método de Saque:
   • Sacar verifica se o valor é positivo e se é menor ou igual ao saldo atual. Caso contrário, lança uma exceção.
4. Exibição do Saldo:
   • ExibirSaldo permite visualizar o saldo e o titular da conta, mas sem dar acesso direto para modificar esses atributos.

 

Conclusão

Neste tópico, exploramos o conceito de encapsulamento na Programação Orientada a Objetos. Com o encapsulamento, conseguimos proteger os dados internos de uma classe e fornecer uma interface segura e controlada para interação. Nos próximos tópicos, abordaremos outros pilares da POO, como herança e polimorfismo, que ajudarão a estruturar ainda melhor o código.

 

 

Continue o curso no próximo post!

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