Programação orientada a objetos em delphi

Programação
orientada a
objetos em
Delphi
Abrindo sua mente para um mundo novo...
mas nem tanto!

Mudar!? Para quê???
Se você chegou até aqui, significa que você
procura por otimizar seu processo de
trabalho!
Então deixe o comodismo e o preconceito de lado!
FreeDigitalPhotos.net

Mas preciso estudar um monte de
teorias novas?
Orientação a Objeto é um conceito antigo.
Mas a melhor maneira de aprender é usando!
Polimorfismo, herança
e encapsulamento são
conceitos importantes!
Mas a prática leva à
perfeição!
FreeDigitalPhotos.net

O que devo saber sobre a teoria?
● Orientação a objetos: Estrutura de
agrupamento de dados e funções que tem
por objetivo alta padronização e
usabilidade de informações.

● Polimorfismo, herança e encapsulamento:
São metodologias utilizadas para se
conseguir, tecnicamente, a padronização e
a usabilidade que são necessários para o
ganho de performance no desenvolvimento
de software.

● Classes, métodos e atributos: São nomes
novos para coisas velhas que você já
conhece! Muda o contexto, mas o conceito
é o mesmo.

Entendendo como se faz
● Classe: É a especificação, o projeto.
● Objeto: É a instancia, em memória, da
classe. Este é o objeto de trabalho!

Unit UConta;
Interface
Uses SysUtils;
Type
TConta = Class
public
numero: integer;
dono: String;
saldo: real;
limite: real;
End;
Implementation
//...

Procedure Teste;
var
vConta: TConta;
vSaldo_Total: real;
begin
vConta:= Tconta.Create;
vConta.saldo := 0;
vConta.dono := 'José';
vSaldo_Total:= vConta.Saldo + vConta.Limite;
vConta.free;
// FreeAndNil(vConta);
end;

● Atributos: São características da classe.
São variáveis que armazenam dados
referente ao objeto.

Unit UConta;
//...
Type
TConta = Class
public
numero: integer;
dono: String;
saldo: real;
limite: real;
public
Procedure saca(valor: real);
Procedure deposita(valor: real);
End;
Implementation
//...

//...
Implementation
Procedure TConta.saca(valor: real);
var vNovoSaldo: real;
begin
vNovoSaldo := saldo - valor;
saldo := vNovoSaldo;
end;
Procedure TConta.deposita(valor: real);
begin
saldo := saldo + valor;
end;
//...

Procedure Teste;
var
vConta: TConta;
vSaldo_Total: real;
begin
vConta:= Tconta.Create;
vConta.saldo := 0;
vConta.dono := 'José';
vConta.deposita(200);
vConta.saca(50);
vSaldo_Total:= vConta.Saldo + vConta.Limite;
vConta.free;
end;

● Métodos: São ações da classe. São
funções ou procedimentos necessários
para a execução dos objetivos da classe.

● Objetos: Lembre-se que, ao instanciar uma
classe, você está fazendo referência a
endereços de memória.
● Cuidado ao referencias objetos e limpa-los
da memória.

Procedure Teste;
var
vC1, vC2, vC3: TConta;
begin
vC1:= Tconta.Create;
vC1.dono := 'José';
vC2.dono := 'Maria';
vC3:=vC1;
vC3.deposita(100);
vC3:=vC2;
vC3.deposita(10);
vC3:=nil;
freeandnil(vC1);
freeandnil(vC2);
end;

Procedure Teste;
var
vC1, vC2: TConta;
begin
vC1.dono := 'Emilia';
vC2.dono := 'Emilia';
if vC1 = vC2 then begin
// são iguais!
end;
freeandnil(vC1);
freeandnil(vC2);
end;

● Aproveite-se das referências de memória
para otimizar seus métodos.

Unit UConta;
//...
Type
TConta = Class;
TConta = Class
public
numero: integer;
dono: String;
saldo: real;
limite: real;
public
Procedure transfere(conta: TConta; valor: real);
End;
Implementation
//...

//...
Implementation
Procedure TConta.transfere(conta: TConta; valor: real);
begin
saldo := saldo - valor;
conta.saldo := saldo + valor;
end;
//ou
Procedure TConta.transfere(conta: TConta; valor: real);
begin
saldo.saca(valor);
conta.deposita(valor);
end;
//...

● Pode-se deixar sua classe mais inteligente
e robusta com a utilização de construtores
e destruidores.

Unit UConta;
Type
TConta = Class;
TConta = Class
public
numero: integer;
dono: String;
saldo: real;
limite: real;
public
Constructor Create;
Destructor Free;
End;
Implementation
//...

//...
Implementation
Procedure TConta.Create;
begin
numero := 0;
dono:= '';
saldo:= 0;
limite: 1000;
end;
Procedure TConta.Free;
begin
// Tratamento de limpeza
end;
//...

● Aproveite a estrutura e pense sempre de
maneira modular.
● Cada classe deve ser especialista no que
faz!

Conta
+ numero: integer;
+ dono: TTitular;
+ saldo: real;
+ limite: real;
+ Constructor Create;
+ Destructor Free;
+ saca(valor: real);
+ deposita(valor: real);
+ transfere(conta: TConta;
valor: real);
Titular
+ nome: String;
+ endereco: String;
+ cpf: String;
+ Constructor Create;
+ Destructor Free;

Unit UTitular;
Type
TTitular = Class
public
nome: string;
endereco: string;
cpf: string;
public
Constructor Create;
Destructor Free;
End;
Implementation
//...

Unit UConta;
Interface
Uses Utitular;
Type
TConta = Class;
TConta = Class
public
numero: integer;
dono: TTitular;
saldo: real;
limite: real;
public
Constructor Create;
Destructor Free;
End;
Implementation
//...

//...
Implementation
begin
numero := 0;
saldo:= 0;
limite: 1000;
dono:= TTitular.Create;
end;
begin
dono.free;
end;
//...

Procedure Teste;
var
vC1: TConta;
begin
vC1.dono.nome := 'Joao';
vC1.dono.CPF := '11122233300';
VC1.saldo:=0;
VC1.deposita(100);
freeandnil(vC1);
end;

Padrão de programação
● Pode-se adotar padrões de programação
orientada a objetos para facilitar o
trabalho em equipe.

Estrutura de classe em Delphi
//-------------------------------------------------------
//<Nome do sistema ou conjunto de classes> - <data>
//<nome da classe>
//<Descrição da classe>
//-------------------------------------------------------
Unit UTTeste;
interface
Uses Sysutils, ZDataset, ZConnection, Classes;
Type
TTeste = Class
private
VARIAVEIS DE ATRIBUTOS
MÉTODOS PRIVADOS: GETS E SETS
MÉTODOS PRIVADOS DIVERSOS
public
CONSTRUTOR
DESTRUTOR
MÉTODOS PÚBLICOS
Estrutura de classe em Delphi
public
DEFINIÇÃO DE PROPRIEDADES,
GETS E SETS
End;
implementation
IMPLEMENTAÇÃO DOS CONSTRUTORES
IMPLEMENTAÇÃO DOS DESTRUTORES
IMPLEMENTAÇÃO DE MÉTODOS
PRIVADOS
IMPLEMENTAÇÃO DE MÉTODOS
PUBLICOS
End;

Unit UConta;
Interface
Uses Utitular;
Type
TConta = Class;
TConta = Class
private
a_numero: integer;
a_dono: TTitular;
a_saldo: real;
a_limite: real;
private
Procedure set_numero(Const Value: integer);
Procedure set_dono(Const Value: TTitular);
Procedure set_saldo(Const Value: real);
Procedure set_limite(Const Value: real);
//...

//...
Function get_numero: integer;
Function get_dono: TTitular;
Function get_saldo: real;
Function get_limite: real;
public
Constructor Create;
Destructor Free;
//...

//...
public
Property Numero: integer read get_numero write
set_numero;
Property Dono: TTitular read get_dono write set_dono;
Property Saldo: real read get_saldo write set_saldo;
Property Limite: real read get_limite write set_limite;
Implementation
//...

//...
begin
a_numero := 0;
a_saldo:= 0;
a_limite: 1000;
a_dono:= TTitular.Create;
end;
begin
a_dono.free;
end;
//...

//...
Procedure TConta.saca(valor: real);
var vNovoSaldo: real;
begin
vNovoSaldo := a_saldo - valor;
a_saldo := vNovoSaldo;
end;
Procedure TConta.deposita(valor: real);
begin
a_saldo := a_saldo + valor;
end;
//...

//...
Procedure TConta.set_numero(Const Value: integer);
begin
a_numero := value;
end;
Procedure TConta.set_dono(Const Value: TTitular);
begin
a_dono := value;
end;
Procedure TConta.set_saldo(Const Value: real);
begin
a_saldo := value;
end;
Procedure TConta.set_limite(Const Value: real);
begin
a_limite := value;
end;
//...

//...
Function TConta.get_numero: integer;
begin
result := a_numero;
end;
Function TConta.get_dono: TTitular;
begin
result := a_dono;
end;
Function TConta.get_saldo: real;
begin
result := a_saldo;
end;
Function TConta.get_limite: real;
begin
result := a_limite;
end;
End.

Concluindo
● Toda a mudança requer um período de
adaptação.
● Os ganhos da POO são muitos, mas é
necessário prática, disciplina e paciência
para quem ainda se inicia na metodologia.

Bibliografia
● Caelum. Apostila Java e Orientação a objetos. http://www.caelum.com.br/apostila-java-
orientacao-objetos/orientacao-a-objetos-basica/
● MELO, Ana Cristina, Desenvolvendo Aplicações com UML 2.0: do conceitual à implementação /
Ana Cristina Melo. – 2. ed. – Rio de Janeiro: Brasport, 2004.
● BORLAND, Treinamento Oficial, Delphi 2005 – Application Development with Delphi for Win32 –
2005.
● DEITEL, H. M. Deitel, C# - Como Programar – São Paulo: Pearson Education do Brasil LTDA,
2003.

Programação orientada a objetos em delphi

Mais conteúdo relacionado

Mais procurados (20)

Destaque (20)

Semelhante a Programação orientada a objetos em delphi (20)

Mais de Helder Lopes (20)

Último (20)

Programação orientada a objetos em delphi