Workshop de sobre programação orientada a objetos para Delphi ministrado para a Hipcom Informática.

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

2. 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

3. 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

4. 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.

5. O que devo saber sobre a teoria?
● 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.

6. O que devo saber sobre a teoria?
● Classes, métodos e atributos: São nomes
novos para coisas velhas que você já
conhece! Muda o contexto, mas o conceito
é o mesmo.

7. Entendendo como se faz
Caelum

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

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

10. Entendendo como se faz
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;

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

12. Entendendo como se faz
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
//...

13. Entendendo como se faz
//...
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;
//...

14. Entendendo como se faz
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;

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

16. Entendendo como se faz
● 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.

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

18. Entendendo como se faz
Procedure Teste;
var
vC1, vC2: TConta;
begin
vC1:= Tconta.Create;
vC1.dono := 'Emilia';
vC2:= Tconta.Create;
vC2.dono := 'Emilia';
if vC1 = vC2 then begin
// são iguais!
end;
freeandnil(vC1);
freeandnil(vC2);
end;

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

20. Entendendo como se faz
Unit UConta;
//...
Type
TConta = Class;
TConta = Class
public
numero: integer;
dono: String;
saldo: real;
limite: real;
public
Procedure saca(valor: real);
Procedure deposita(valor: real);
Procedure transfere(conta: TConta; valor: real);
End;
Implementation
//...

21. Entendendo como se faz
//...
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;
//...

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

23. Entendendo como se faz
Unit UConta;
Type
TConta = Class;
TConta = Class
public
numero: integer;
dono: String;
saldo: real;
limite: real;
public
Constructor Create;
Destructor Free;
Procedure saca(valor: real);
Procedure deposita(valor: real);
Procedure transfere(conta: TConta; valor: real);
End;
Implementation
//...

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

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

26. Entendendo como se 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;

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

28. Entendendo como se faz
Unit UConta;
Interface
Uses Utitular;
Type
TConta = Class;
TConta = Class
public
numero: integer;
dono: TTitular;
saldo: real;
limite: real;
public
Constructor Create;
Destructor Free;
Procedure saca(valor: real);
Procedure deposita(valor: real);
Procedure transfere(conta: TConta; valor: real);
End;
Implementation
//...

29. Entendendo como se faz
//...
Implementation
Procedure TConta.Create;
begin
numero := 0;
saldo:= 0;
limite: 1000;
dono:= TTitular.Create;
end;
Procedure TConta.Free;
begin
dono.free;
end;
//...

30. Entendendo como se faz
Procedure Teste;
var
vC1: TConta;
begin
vC1:= Tconta.Create;
vC1.dono.nome := 'Joao';
vC1.dono.CPF := '11122233300';
VC1.saldo:=0;
VC1.deposita(100);
freeandnil(vC1);
end;

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

32. Padrão de programação
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;

33. Padrão de programação
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);
//...

34. Padrão de programação
//...
Function get_numero: integer;
Function get_dono: TTitular;
Function get_saldo: real;
Function get_limite: real;
public
Constructor Create;
Destructor Free;
Procedure saca(valor: real);
Procedure deposita(valor: real);
Procedure transfere(conta: TConta; valor: real);
//...

35. Padrão de programação
//...
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
//...

36. Padrão de programação
//...
Procedure TConta.Create;
begin
a_numero := 0;
a_saldo:= 0;
a_limite: 1000;
a_dono:= TTitular.Create;
end;
Procedure TConta.Free;
begin
a_dono.free;
end;
//...

37. Padrão de programação
//...
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;
//...

38. Padrão de programação
//...
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;
//...

39. Padrão de programação
//...
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.

40. 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.

41. 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.