Encapsulamento em Delphi

Por
Encapsulamento em Delphi
Mãos em cima de um teclado de notebook com uma calculadora e uma caneta ao lado

Introdução

Nesse post iremos aprender sobre Encapsulamento em Delphi dentro da Orientação a Objetos. Iremos pontuar o conceito, benefícios e exemplo prático com código fonte completo, para elevar seus conhecimentos em Delphi para outros nível.

Conceito, Benefícios e Exemplo Prático

Encapsulamento é um dos conceitos fundamentais da programação orientada a objetos (POO). Ele envolve o agrupamento de dados e métodos que operam sobre esses dados dentro de uma única unidade chamada classe, enquanto protege esses dados de acesso indevido. Neste artigo, exploraremos o conceito de encapsulamento em Delphi, o uso de modificadores de acesso, os benefícios do encapsulamento e apresentaremos um exemplo prático para ilustrar seu uso.

Conceito de Encapsulamento em Delphi

Encapsulamento refere-se à técnica de esconder os detalhes internos de um objeto e expor apenas o que é necessário através de uma interface bem definida. Isso significa que os dados dentro de uma classe são acessíveis apenas através de métodos públicos da mesma classe, enquanto os detalhes de implementação são mantidos privados ou protegidos.

Modificadores de Acesso: Public, Private, Protected

Delphi utiliza modificadores de acesso para controlar a visibilidade e o acesso aos membros de uma classe. Aqui estão os principais modificadores:

  • Public: Membros declarados como public são acessíveis de qualquer lugar.
  • Private: Membros declarados como private são acessíveis apenas dentro da classe onde foram declarados.
  • Protected: Membros declarados como protected são acessíveis dentro da própria classe e em classes derivadas.

Benefícios do Encapsulamento

  1. Segurança: Protege os dados internos da classe contra modificações indevidas.
  2. Manutenção: Facilita a manutenção do código, permitindo que a implementação interna seja alterada sem afetar outras partes do sistema.
  3. Reutilização: Promove a reutilização de código ao criar componentes modulares e independentes.
  4. Facilidade de Uso: Simplifica o uso da classe, expondo apenas os métodos e propriedades necessários.

Exemplo Prático com Código

Vamos criar uma classe TContaBancaria para demonstrar o uso do encapsulamento em Delphi. Esta classe terá atributos privados para o saldo e o número da conta, e métodos públicos para depositar, sacar e verificar o saldo.

Configurando o Ambiente

  1. Abrindo o Delphi: Abra o Delphi e crie um novo projeto VCL Forms Application.
  2. Configurando o Formulário Principal: Adicione o seguinte componente ao formulário:
  • TButton (btnExibirDados): Para executar exibir os dados da conta bancária.

Definindo a Classe TContaBancaria

type
  TContaBancaria = class
  private
    FNumeroConta: String;
    FSaldo: Double;
    procedure SetNumeroConta(const Value: String);
    procedure SetSaldo(const Value: Double);
  public
    constructor Create(NumeroConta: String; SaldoInicial: Double);
    procedure Depositar(Valor: Double);
    procedure Sacar(Valor: Double);
    function GetSaldo: Double;
    function GetNumeroConta: String;
  end;

Atributos Privados

  • FNumeroConta: String;
    Este é um atributo privado que armazena o número da conta bancária.
  • FSaldo: Double;
    Este é um atributo privado que armazena o saldo da conta bancária.

Os atributos FNumeroConta e FSaldo são privados, o que significa que eles não podem ser acessados diretamente de fora da classe. Para acessar e modificar esses atributos, usamos métodos públicos.

Métodos Privados

  • procedure SetNumeroConta(const Value: String);
  • procedure SetSaldo(const Value: Double);

Os métodos SetNumeroConta e SetSaldo são privados e são usados internamente para definir os valores dos atributos FNumeroConta e FSaldo, respectivamente.

Métodos Públicos

  • constructor Create(NumeroConta: String; SaldoInicial: Double);
    O construtor Create é um método especial que inicializa uma nova instância da classe TContaBancaria. Ele recebe como parâmetros o número da conta e o saldo inicial.
  • procedure Depositar(Valor: Double);
    O método Depositar adiciona um valor ao saldo da conta, desde que o valor seja positivo.
  • procedure Sacar(Valor: Double);
    O método Sacar subtrai um valor do saldo da conta, desde que o valor seja positivo e não exceda o saldo disponível.
  • function GetSaldo: Double;
    O método GetSaldo retorna o saldo atual da conta.
  • function GetNumeroConta: String;
    O método GetNumeroConta retorna o número da conta bancária.

Implementação dos Métodos

implementation

constructor TContaBancaria.Create(NumeroConta: String; SaldoInicial: Double);
begin
  FNumeroConta := NumeroConta;
  FSaldo := SaldoInicial;
end;

procedure TContaBancaria.Depositar(Valor: Double);
begin
  if Valor > 0 then
    FSaldo := FSaldo + Valor;
end;

procedure TContaBancaria.Sacar(Valor: Double);
begin
  if (Valor > 0) and (Valor <= FSaldo) then
    FSaldo := FSaldo - Valor;
end;

procedure TContaBancaria.SetNumeroConta(const Value: String);
begin
  FNumeroConta := Value;
end;

procedure TContaBancaria.SetSaldo(const Value: Double);
begin
  if Value >= 0 then
    FSaldo := Value;
end;

function TContaBancaria.GetSaldo: Double;
begin
  Result := FSaldo;
end;

function TContaBancaria.GetNumeroConta: String;
begin
  Result := FNumeroConta;
end;

Construtor

O construtor Create inicializa a instância da classe TContaBancaria com o número da conta e o saldo inicial fornecidos como parâmetros:

constructor TContaBancaria.Create(NumeroConta: String; SaldoInicial: Double);
begin
  FNumeroConta := NumeroConta;
  FSaldo := SaldoInicial;
end;

Métodos Públicos

  • Depositar: Adiciona um valor ao saldo, se o valor for positivo:
procedure TContaBancaria.Depositar(Valor: Double);
begin
  if Valor > 0 then
    FSaldo := FSaldo + Valor;
end;
  • Sacar: Subtrai um valor do saldo, se o valor for positivo e não exceder o saldo disponível:
procedure TContaBancaria.Sacar(Valor: Double);
begin
  if (Valor > 0) and (Valor <= FSaldo) then
    FSaldo := FSaldo - Valor;
end;
  • SetNumeroConta: Define o número da conta:
procedure TContaBancaria.SetNumeroConta(const Value: String);
begin
  FNumeroConta := Value;
end;
  • SetSaldo: Define o saldo da conta, se o valor for positivo:
procedure TContaBancaria.SetSaldo(const Value: Double);
begin
  if Value >= 0 then
    FSaldo := Value;
end;
  • GetSaldo e GetNumeroConta: Retornam o saldo e o número da conta, respectivamente:
function TContaBancaria.GetSaldo: Double;
begin
  Result := FSaldo;
end;

function TContaBancaria.GetNumeroConta: String;
begin
  Result := FNumeroConta;
end;

Utilizando a Classe TContaBancaria

Vamos ver como utilizar a classe TContaBancaria em um formulário Delphi:

procedure TForm1.btnExibirDadosClick(Sender: TObject);
var
  Conta: TContaBancaria;
begin
  Conta := TContaBancaria.Create('123456', 1000.00);
  ShowMessage('Número da Conta: ' + Conta.GetNumeroConta);
  ShowMessage('Saldo Inicial: ' + FloatToStr(Conta.GetSaldo));

  Conta.Depositar(500.00);
  ShowMessage('Saldo após depósito: ' + FloatToStr(Conta.GetSaldo));

  Conta.Sacar(200.00);
  ShowMessage('Saldo após saque: ' + FloatToStr(Conta.GetSaldo));
end;

Neste exemplo, criamos uma instância de TContaBancaria e realizamos algumas operações:

  1. Criamos uma conta com o número ‘123456’ e saldo inicial de 1000.00.
  2. Mostramos o número da conta e o saldo inicial.
  3. Depositamos 500.00 na conta e mostramos o saldo atualizado.
  4. Sacamos 200.00 da conta e mostramos o saldo final.

Código completo

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type

  TContaBancaria = class
  private
    FNumeroConta: String;
    FSaldo: Double;
    procedure SetNumeroConta(const Value: String);
    procedure SetSaldo(const Value: Double);
  public
    constructor Create(NumeroConta: String; SaldoInicial: Double);
    procedure Depositar(Valor: Double);
    procedure Sacar(Valor: Double);
    function GetSaldo: Double;
    function GetNumeroConta: String;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure btnExibirDadosClick(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TContaBancaria }

constructor TContaBancaria.Create(NumeroConta: String; SaldoInicial: Double);
begin
  FNumeroConta := NumeroConta;
  FSaldo := SaldoInicial;
end;

procedure TContaBancaria.Depositar(Valor: Double);
begin
  if Valor > 0 then
    FSaldo := FSaldo + Valor;
end;

function TContaBancaria.GetNumeroConta: String;
begin
  Result := FNumeroConta;
end;

function TContaBancaria.GetSaldo: Double;
begin
  Result := FSaldo;
end;

procedure TContaBancaria.Sacar(Valor: Double);
begin
  if (Valor > 0) and (Valor <= FSaldo) then
    FSaldo := FSaldo - Valor;
end;

procedure TContaBancaria.SetNumeroConta(const Value: String);
begin
  FNumeroConta := Value;
end;

procedure TContaBancaria.SetSaldo(const Value: Double);
begin
  if Value >= 0 then
    FSaldo := Value;
end;

{ TForm1 }

procedure TForm1.btnExibirDadosClick(Sender: TObject);
var
  Conta: TContaBancaria;
begin
  Conta := TContaBancaria.Create('123456', 1000.00);
  ShowMessage('Número da Conta: ' + Conta.GetNumeroConta);
  ShowMessage('Saldo Inicial: ' + FloatToStr(Conta.GetSaldo));

  Conta.Depositar(500.00);
  ShowMessage('Saldo após depósito: ' + FloatToStr(Conta.GetSaldo));

  Conta.Sacar(200.00);
  ShowMessage('Saldo após saque: ' + FloatToStr(Conta.GetSaldo));

end;

end.

Veja abaixo como ficou a ilustração do projeto utilizando Encapsulamento:

Encapsulamento em Delphi
Ilustração do projeto

Código fonte do exemplo

Você pode fazer o download do exemplo do projeto através do repositório do github:

https://github.com/Gisele-de-Melo/Encapsulamento

Conclusão

Este exemplo demonstra como usar o encapsulamento para proteger e controlar o acesso aos dados de uma classe em Delphi. Usamos modificadores de acesso para definir quais membros são públicos e quais são privados. Isso ajuda a garantir que os dados internos de uma classe sejam manipulados de maneira controlada, mantendo a integridade dos dados e facilitando a manutenção do código. Ao aplicar essas técnicas, você pode criar aplicações mais robustas e fáceis de manter.

O encapsulamento é uma prática essencial na programação orientada a objetos que melhora a segurança, manutenção, reutilização e facilidade de uso do código. Em Delphi, o uso de modificadores de acesso como public, private e protected permite controlar a visibilidade dos membros da classe, protegendo os dados internos e expondo apenas os métodos necessários. O exemplo prático com a classe TContaBancaria demonstra como aplicar o encapsulamento em um projeto Delphi.

Ao adotar essas técnicas e práticas, você pode desenvolver aplicações mais robustas e eficientes. Continue explorando e aprimorando suas habilidades em Delphi para criar soluções ainda mais sofisticadas e bem estruturadas.

Posts Relacionados

Orientação a Objetos em Delphi

Orientação a Objetos em Delphi.

Classes e Objetos em Delphi

Deixe um comentário