Introdução a OO
Orientação a Objetos é o nome que os pesquisadores da computação na década de 70 usaram
para batizar este novo “paradigma”, que tinham acabado de inventar. E não é para menos,
pois veremos que neste estilo de programação – como queriam os seus criadores – tudo é
objeto. Ou ao mínimo, se pretende que seja.
Orientação a Objetos procura rearranjar a programação estruturada de uma maneira
diferente, e talvez bem mais compreensiva ao raciocínio do homem. Ela pretende descrever a
solução através de objetos – como no mundo real – ao contrário da programação estruturada,
que o faz através de passos e comandos, de maneira semelhante a uma receita de bolo.
Um paradigma, caso o leitor não saiba, é uma maneira diferente de se tentar enxergar uma
mesma coisa, um mesmo mundo. O Paradigma OO busca bases filosóficas para tentar traduzir
um mundo mais humano às instruções que o processador realmente entende. E é de viagens
deste tipo, combinadas à estrutura de linguagens imperativas como o C ou Pascal, que surgem
as linguagens OO. E estas últimas se responsabilizam pela existência da maioria dos grandes
softwares produzidos nos dias atuais em todo o mundo.
Desde que surgiu, a computação tem evoluído de uma maneira bastante rápida. Esta evolução
acabou levando a comunidade deste meio a se deparar com a chamada “crise do software”. A
orientação a objetos surgiu nos primórdios da década de 70, com as linguagens ADA, SIMULA
e Small Talk. Ela ficou bastante difundida nos anos 80, com linguagens como o C++, e teve uma
recente explosão em difusão nos anos 90, através da linguagem Java. Hoje em dia é muito
comum encontrarmos compiladores e tradutores para linguagens OO, tais como Object Pascal,
C++, Java e Visual Object.
A “crise do software” acabou levando os desenvolvedores da época a buscar uma solução
alternativa, pois a complexidade dos sistemas já havia chegado a tal ponto que nem os seus
programadores conseguiam dominá-la mais. Sabia-se que as linguagens estruturadas não
davam mais suporte às necessidades, e esta possivelmente tenha sido a principal causa do
surgimento das linguagens OO.
Também não é para menos. Se você tentar olhar um programa como o AutoCAD com os
olhos de programador, irá entender o que queremos dizer com a palavra “complexidade”.
Para um programador experiente em OO, fica difícil sequer imaginar uma solução destas sem
que se modele um mundo de objetos. Daí a nossa intenção em dizer que a POO surgiu para
suprir a crise do software – e conseguir dividir os sistemas de maior complexidade em partes
independentes e que possam, assim, se manter sob o controle de seus criadores.
3
Classes e Objetos
Classe é o conjunto de Métodos e Atributos utilizados para representar algo.
Exemplo de criação de uma classe:
TAnimal = Class
End;
Um objeto é uma instancia de uma classe. Exemplo:
Procedure CriarAnimal;
Var
Cachorro: TAnimal;
Begin
Cachorro := TAnimal.Create;
End;
Um exemplo prático de classe e objeto é:
Ser humano é a classe, e João da Silva é o Objeto da Classe Ser humano.
Instanciar é o ato de criar um objeto na memória do computador. Ao criar um objeto, esse
objeto é guardado em um endereço de memória do computador.
4
Atributos e Métodos
Métodos e Atributos são as características da classe.
Exemplo:
TAnimal = Class
Nome: String;
Altura, Peso: Real;
Procedure Crescer(Aumento: Real);
End;
Procedure TAnimal.Crescer(Aumento: Real);
Begin
Altura := Altura + Aumento;
End;
Nome, Peso e Altura são características da classe criada. O procedimento Crescer é um
método da classe TAnimal. As características de uma classe são, em geral, variáveis e os
métodos são, em geral, procedimentos e funções.
5
Declarações Públicas, Privadas, Protegidas e Publicadas.
Os métodos e atributos da classe podem ser declarados de maneira que a visibilidade seja
restrita. As declarações podem ser:
· Públicas: Todas os objetos dessa classe podem utilizar os métodos e atributos.
· Privadas: Apenas a própria classe tem acesso aos métodos e atributos.
· Protegidas: A própria classe e as classes descendentes tem acesso aos métodos e
atributos.
· Publicadas: Utilizado para componentes. Os métodos e atributos declarados aparecerão
na aba “Object Inspector” do IDE do Delphi.
6
Propriedades
Propriedades são características da classe, capazes de realizar verificações antes de serem
lidas ou escritas.
Exemplo:
TAnimal = Class
private
Nome: String;
FAltura: Real;
Procedure SetAltura(const Value: Real);
Function GetAltura: Real;
Public
Property Altura: Real read GetAltura write SetAltura;
End;
Procedure TAnimal.SetAltura(const Value: Real);
Begin
If Value<0 then
Raise Exeption.Create(‘Altura não pode ser menor que Zero’)
Else
FAltura := Value;
End;
function TAnimal.GetAltura: Real;
Begin
Result := FAltura;
End;
Quando for atribuído um valor para a propriedade Altura, será executado o procedimento
SetAltura, que verificará se a altura é positiva.
Ao ler o valor da propriedade, será executado a função GetAltura, que restornará o valor da
Variavel FAltura.
7
Construtores e Destrutores
Contrutores e Destrutores são métodos que serão executados na criação e destruição do
objeto da classe. A criação é o momento que o objeto é instanciado, ou seja, criado um
endereço de memória. A destruição é o momento inverso ao da criação, ou seja, no momento
que o objeto é liberado da memoria, ou seja, perde seu endereço de memória.
TAnimal = Class
Nome: String;
Altura, Peso: Real;
Constructor Create(NomeAnimal: String);
Destructor Destroy;
End;
Contructor TAnimal.Create(NomeAnimal: String);
Begin
Nome:=NomeAnimal;
End;
Destructor TAnimal.Destroy;
Begin
Nome := ‘’
End;
Em Delphi, toda classe tem um método chamado Free. Ao chamadar o método Free, será
executado o Destroy da classe, caso houver. Exemplo:
Var Cachorro: TAnimal;
Begin
Cachorro.Free;
End;
O método Free é responsável por deslocar o objeto da memória.
8
Herança
Uma das grandes vantagens da OO é a herança. Herança é a capacidade que uma classe tem
de herdar características de outra classe. A classe herdada é chamada de ancestral e a classe
que herdou é chamada de descendente.
TSerVivo = Class
Nome: String;
Alimento: String;
End;
TAnimal = Class(TSerVivo)
Membros: Integer;
End;
TVegetal = Class(TSerVivo)
Fruto: String;
End;
Dessa maneira, todo TVegetal e TAnimal é também um TSerVivo. Sendo um TSerVivo, possui
seus atributos e métodos. Podemos assim dizer, que todo TAnimal e TVegetal também possui
Nome e Alimeto.
Entretando, TAnimal e TVegetal são classes diferentes. TAnimal não possui um atributo Fruto,
e TVegetal não possui uma atributo Membros.
Vale ressaltar que se o atributo Nome da classe TSerVivo estivesse declarado em Private, seus
descendentes não teriam acesso à esse atributo. Os descendentes apenas tem acesso aos
métodos e atributos declarados em Public, Protected ou Published.
9
Métodos Virtuais, Abstratos e Sobrecarregados
Métodos Virtuais
Métodos virtuais são métodos que podem ser modificados em classes decendentes.
TSerVivo = Class
Nome: String;
Alimento: String;
Procedure MostraAtributos; Virtual;
End;
Procedure TSerVivo.MostraAtributos;
Begin
ShowMessage(‘Nome: ‘+Nome);
ShowMessage(‘Alimento: ‘+Alimento);
End;
TAnimal = Class(TSerVivo)
Membros: Integer;
Procedure MostraAtributos; Override;
End;
Procedure TAnimal.MostraAtributos;
Begin
Inherited;
ShowMessage(‘Membros: ‘+IntToStr(Membros));
End;
Neste caso o Metodo MostraAtributos da classe TSetVivo é virtual, ou seja, pode ser
sobrescrito (override) pela classe descendente (TAnimal).
A palavra Inherited significa que deve executar todo o procedimento da classe ancestral
(TSerVivo.MostraAtributos). Se tirar o Inherited, apenas motrará a mensagem dos membros.
Obviamente, se por a palavra Inherited por ultimo no método TAnimal.MostraAtributos, a
primeira mensagem que irá mostrar será a dos membros, depois mostrará os outros atributos.
10
Métodos Abstratos
Métodos abtratos são métodos que não podem ter implementação na classe ancestral.
TSerVivo = Class
Nome: String;
Alimento: String;
Procedure MostraAtributos; Abstract;
End;
TAnimal = Class(TSerVivo)
Membros: Integer;
Procedure MostraAtributos; Override;
End;
Procedure TAnimal.MostraAtributos;
Begin
ShowMessage(‘Nome: ‘+Nome);
ShowMessage(‘Alimento: ‘+Alimento);
ShowMessage(‘Membros: ‘+IntToStr(Membros));
End;
Neste caso, o método TSerVivo.MostraAtributos é abstrato e não pode ter implementação.
Entretanto, as classes decendentes de TSerVivo podem ter a implementação do método
MostraAtributos.
Se tentar executar o método MostraAtributos sem a implementação, apresentará a mensagem
de erro “Abstract Error”.
11
Métodos Sobrecarregados
Métodos Sobrecarregados são métodos que podem ter duas ou mais declarações usando
parâmetros diferentes.
TAnimal = Class(TSerVivo)
Membros: Integer;
Procedure MostraAtributos; Overload;
Procedure MostraAtributos(Tamanho: Integer); Overload;
End;
Procedure TAnimal.MostraAtributos;
Begin
ShowMessage(‘Nome: ‘+Nome);
ShowMessage(‘Alimento: ‘+Alimento);
ShowMessage(‘Membros: ‘+IntToStr(Membros));
End;
Procedure TAnimal.MostraAtributos(Tamanho: Integer);
Begin
MostraAtributos;
ShowMessage(‘Tamanho: ‘+IntToStr(Tamanho));
End;
Neste caso, o método MostraAtributos possui duas declarações diferentes. Se chamar o
método MostraAtributos sem informar nenhum parâmetro, apenas mostrara as mensagens
de Nome, Alimento e Membros. Se chamar o método MostraAtributos e informar o Tamanho,
mostrará, além das mensagens de MostraAtributos sem parâmetros, também a mensagem do
Tamanho.
12
