UNIP – UNIVERSIDADE PAULISTA
INSTITUTO DE CIÊNCIAS EXATAS E TECNOLOGIA (ICET)
CURSO DE CIÊNCIAS DA COMPUTAÇÃO
O Paradigma da Orientação a Objeto
Apresentada em Cumprimento Parcial dos
Requerimentos para o Curso de Ciências da Computação
Disciplina de Paradigmas de Programação, Professor Willian Zacarotto
Por
Alberto José Araujo 753384-5
Danilo Rodrigues Pereira 522306-7
Fevereiro 2005
-2-
SUMÁRIO
ABSTRAÇÃO ........................................................................................................................3
VARIÁVEIS ESTÁTICAS X DINÂMICAS.........................................................................4
FILA EM PASCAL / DELPHI ...............................................................................................8
FILA EM OOP......................................................................................................................10
PROGRAMAÇÃO MODULAR ..........................................................................................11
EMCAPSULAMENTO ........................................................................................................12
OCLUSÃO DE INFORMAÇÕES........................................................................................12
PASSOS DE MONTAGEM DE UM PROGRAMA OOP. EM JAVA ...............................13
PROGRAMAÇÃO ORIENTADA A OBJETO ...................................................................14
HERANÇA ...........................................................................................................................16
POLIMORFISMO ................................................................................................................19
MÉTODO .............................................................................................................................21
CLASSES E OBJETOS........................................................................................................22
MODELAGEM DE DADOS ...............................................................................................22
REUTILIZACAO .................................................................................................................23
BIBLIOGRAFIA ..................................................................................................................24
-3-
ABSTRAÇÃO DE DADOS
1 – Conceito
É uma forma de resolver um problema sem preocupar-se com os detalhes, observando
apenas os aspectos de interesse. Não levando em conta em qual tipo de computador será usado e
nem a linguagem que será usada.
Exemplo:
Verificar se um determinado número é par ou impar.
Para resolver esse problema simples primeiramente devemos pensar quais as condições
para que o numero seja par. Todo numero par é divisível por 2. Resolvido o problema depois é
só fazer a implementação na linguagem desejada.
Implementação em Pascal
Function par (N: real): Boolean;
Begin
if ( N mod 2 = 0 ) then
par := true;
end;
-4-
Outro exemplo:
Calcular a área de um triangulo.
Para resolver esse problemas, primeiramente devemos saber qual a formula para calcular a área
de um triangulo ( A = (base * altura )/2). Depois disso é só passar essa formula para a linguagem
desejada.
VARIÁVEIS ESTÁTICAS X DINÂMICAS
Até agora lidamos com variáveis que tiveram de ser criadas antes de se executar um
programa. São variáveis que existem o tempo todo (em tempo de execução), ou seja, são
variáveis estáticas. Portanto a alocação de memória para esse tipo de variável é feita antes da
execução do programa (compilação). A desvantagem é que uma vez criada esse espaço de
memória não pode ser alterado. As variáveis dinâmicas podem ser criadas e destruídas durante a
execução do programas. Essa é a grande vantagem sobre as estáticas.
Ponteiro ou apontador (Pointer em pascal)
São variáveis que aponta para um determinado endereço de memória (E.G endereço de
outras variáveis). Ou seja, ela aponta a um local da memória onde está armazenada uma variável.
Ex var P: ^integer;
Após esta declaração, teríamos criado uma variável do tipo Ponteiro que ocupa 4 bytes
(lembre-se que ela aponta um endereço, e como sabemos, no IBM/PC, um endereço é formado
pelo Segment e pelo offset, cada um com 2 bytes) e que irá apontar uma variável do tipo Integer.
Utilizamos como exemplo o tipo Integer, mas poderia ser qualquer outro tipo e até mesmo
Record.
-5-
Até esse instante, não criamos a tão famosa variável dinâmica, e sim uma variável do tipo
Ponteiro, que irá apontar o endereço de uma variável dinâmica do tipo Integer.
E dado isto, perguntamos: para onde está apontando a variável recém-criada chamada p?
Simplesmente para nenhum lugar. Isto recebe o nome em Pascal de NIL. Quando escrevemos no
meio de um programa a declaração abaixo:
p := NIL;
Estamos querendo dizer que a variável do tipo Ponteiro, chamada p, não está apontando
para nenhuma variável no momento. Sempre que criamos uma variável do tipo Ponteiro, ela tem
o valor inicial NIL Passo 2: Criação de variáveis dinâmicas
O próximo passo é a criação de uma variável dinâmica, para tanto, utilizamos a procedure
New. Sua sintaxe é:
New(p);
Isto faz com que seja alocado um espaço de memória, suficiente para armazenar uma
variável do tipo associado a p, no caso Integer. Esse espaço de memória fica num local especial
chamado HEAP. No caso do IBM/PC, o HEAP é toda a memória não utilizada pelo sistema.
Portanto, a declaração New(p) aloca um espaço de memória no HEAP, suficiente para
armazenar uma variável do tipo Integer e retorna o endereço inicial desta região de memória para
a variável p. Lembre-se que p é do tipo Ponteiro.
-6-
Exemplo usando variáveis dinâmicas.
Program Exemplo;
Uses CRT;
{Este programa lê registros com a estrutura abaixo, até que se
digite 'fim' quando é perguntado o nome da pessoa. Repare que o
programa tem a capacidade de ler um número ilimitado de
registros sem a preocupação de se definir um array e sua
respectiva dimensão.}
Nome : String[30];
Sexo : Char;
Idade : Integer;
Altura: Real;
Type
Pessoa = Record
Nome : String[30];
Sexo : Char;
Idade : Integer;
Altura: Real;
End;
ponteiro = ^Pessoas;
Pessoas = Record
Valor : Pessoa;
Prox : Ponteiro;
End;
Var
p,prim : Ponteiro;
Procedure Linha;
Var i:integer;
Begin
For i:=1 to 80 do write('-')
End;
Begin
Prim:=nil;
ClrScr;
Repeat
Linha;
New(p);
-7-
Write('Nome da pessoa -----> ');
Readln(p^.valor.Nome);
If (p^.valor.Nome<>'fim')
Then Begin
Write('Sexo ---------------> ');
Readln(p^.valor.Sexo);
Write('Idade --------------> ');
Readln(p^.valor.Idade);
Write('Altura -------------> ');
Readln(p^.valor.altura);
p^.Prox:=Prim;
Prim:=p;
End;
Until p^.valor.nome='fim';
ClrScr;
Linha;
p:=prim;
While p<>nil do
Begin
With p^.valor do
Writeln(nome:30,sexo:5,idade:5,altura:6:2);
p:=p^.prox;
End;
End.
-8-
FILA EM PASCAL / DELPHI
Criaremos um programa para cadastrar 1000 funcionários de uma empresa. Usando os 2
tipos de variáveis.
Estáticas:
Type
Funcionário = record
Nome : string[30];
Salário : real;
Setor : string[30];
Funcao : string[20];
end.
Var
EMPRESA: ARRAY[1..1000] OF FUNCIONARIO ;
Representação
1
Funcionario
2
3
Funcionario
Dinâmicas :
Type
Funcionário = record
Nome : string[30];
Salário : real;
Setor : string[30];
Funcao : string[20];
Prox : ^Funcionario;
end.
Var
P :^Funcionario;
procedure insere(x:Funcionario);
.......
Funcionario
1000
Funcionario
-9-
end;
var
elemento : Funcionario;
begin
if (p= nil) then
p:=x
else
elemento:=p;
while (elemento.prox = nil) do
begin
elemento:= elemento.prox;
end;
elemento.prox:= x;
Representação:
- 10 -
FILA EM OOP
A implementação desse objeto esta encapsulado, ou seja, não podendo ser acessado
pelo usuário, mas isso não quer dizer que ele não exista. A interface é a integração direita entre
o usuário e o objeto.
Exemplo: Um Aparelho de DVD. Para abrir o drive apertamos um botão (objeto do
DVD), nesse mesmo instante estamos acionando um EVENTO DESSE BOTÃO chamado
(ABRIR), que abrirá o drive. Mas aconteceram muitas coisas internamente para que isso
acontecesse, que seria os ATRIBUTOS.
- 11 -
PROGRAMAÇÃO MODULAR
Em Pascal e Delphi podemos criar nossas próprias bibliotecas UNIT contendo
procedures e funções.
Exemplo:
Unit DANILO;
Implementation
Crt;
Interface
Procedure alterarsalario(var X : real);
Begin
{comandos}
End;
Procedure inserir;
Begin
{comandos}
End;
End.
Program Fuincionario;
Uses crt, DANILO;
Begin
Clrscr; {crt}
Writeln( ´Digite o seu salario´, salário);
Novosalario:= alterarsalario;
End.
- 12 -
PRINCIPAIS CARACTERÍSTICAS
•
Encapsulamentos de dados e funções
•
Restrições à visualização das variáveis, constantes e módulos;
•
Separação do “O QUE É FEITO” do “COMO É FEITO”.
ENCAPSULAMENTO
É agrupamentos de idéias em uma mesma unidade.
•
Código (funções e procedimentos).
•
Dados (vetores e registros).
•
Código + Dados (Classes e Objetos).
OCLUSÃO DE INFORMAÇÕES
•
Restrições à visualização - BIBLIOTECAS
•
Classes com interface, onde somente os atributos são públicos (public), isso
garante que as modificações em alguma subclasse não afetaram essa classe e sim
somente os atributos públicos.
- 13 -
PASSOS DE MONTAGEM DE UM PROGRAMA OOP. EM JAVA
- 14 -
PROGRAMAÇÃO ORIENTADA A OBJETO
INTRODUÇÃO
A Metodologia Orientada a Objetos teve sua grande expansão nos anos 90, quando se
tornou a principal metodologia de desenvolvimento de software. Permite modelar de forma mais
natural o mundo real, pois as estruturas de dados são vistas como objetos, ou seja, têm
características e funções. Tem seu maior objetivo por aumentar a produtividade do
desenvolvimento de software através de uma maior expansibilidade e reutilização de código,
além de controlar a complexidade e o custo da manutenção do mesmo.
Quando utilizada, a fase de projeto do desenvolvimento do software está mais intimamente
ligada à fase de implementação. Um dos pontos chaves desta metodologia é centralização das
atenções nas Estruturas de Dados, ao contrário da metodologia estruturada, onde a atenção era
centralizada nos procedimentos. Na orientação a objetos há uma maior aproximação entre dados
e procedimentos, pois procedimentos são definidos em termos dos dados.
Definição: o termo orientação a objetos significa organizar o mundo real como uma
coleção de objetos que incorporam estrutura de dados e um conjunto de operações que
manipulam estes dados.
Todas as linguagens orientadas a objetos possuem três características básicas:
•
Objetos
•
Polimorfismo
•
Herança
- 15 -
As linguagens de POO podem ser divididas em dois grupos:
Puras : projetadas especificamente para o paradigma de OO : Smalltalk, Eiffel e Java
Híbridas : Extensões de linguagens tradicionais e suportam tanto o estilo tradicional
quanto o OO : (C++, Objective-C, CLOS e dialetos OO de Pascal)
Componentes Básicos da Orientação a Objetos
Classe
→ São moldes através dos quais criamos objetos
Objeto
→ Abstração que agrupa características e comportamentos.
Instância
→ É o objeto propriamente dito. Possui características próprias.
Propriedade
→ Define as características dos objetos de uma classe.
Método
→ Define o comportamento dos objetos de uma classe.
Mensagem
→ Representa uma ação do objeto ou uma mudança de estado. Define a
comunicação entre objetos.
Interface
→ Conjunto de mensagens que define o comportamento de um objeto
(Protocolo).
- 16 -
HERANÇA
Permite que uma nova classe seja descrita a partir de outra classe já existente
(Reutilização).
A subclasse herda as características e o comportamento da superclasse.
A subclasse pode adicionar novas características e comportamentos aos herdados da
superclasse.
A subclasse pode ter um comportamento diferente da superclasse, redefinindo o método
herdado.
A subclasse é uma especialização da superclasse.
Toda instância da subclasse é também uma instância da superclasse.
O resultado de uma seqüência de heranças é uma hierarquia de classes.
Exemplificando, sob o ponto de vista administrativo (no contexto de um banco, por
exemplo) a noção de Pessoa geralmente é subdividida (subclassificada) em: Pessoa Física (um
ente individual) e Pessoa Jurídica (uma empresa ou sociedade).
Uma possível descrição da estrutura (hierarquia de agregação /decomposição) de cada uma
destas classes poderia ser:
- 17 -
Note que as três propriedades mais à esquerda (Nome, Endereço e Telefone) são comuns às
duas classes. Como ambas as classes são subclasses da classe Pessoa, estas propriedades podem
ser mais bem descritas diretamente na classe Pessoa, evitando, desta forma, a repetição
observada acima.
O efeito final é o mesmo, ou seja, os objetos pertencentes às classes PessoaFísica e
PessoaJurídica terão as seis propriedades que lhe são características (as três comuns, mais as três
- 18 -
particulares). Isto ocorre em função das classes PessoaFísica
e PessoaJurídica serem
especializações da classe Pessoa e, portanto, herdarem as suas propriedades.
A herança de propriedades também ações. Considere a hierarquia de especialização
/generalização que se segue. Nela está expresso que Mamífero e Ave são subclasses
(especializações) de Animal, e que Homem, Gato e Cão são subclasses de Mamífero.
Uma ação característica de todos os mamíferos é mamar. Portanto, descreve-se esta ação
diretamente na classe Mamífero, de forma que, por herança, todas as subclasses passam a
apresentar esta propriedade. Evita-se, assim, a necessidade de descrever esta ação em cada uma
das subclasses de Mamífero. Similarmente, uma ação característica de todos os animais é olhar.
Por herança, as subclasses imediatas de Animal (Ave, Mamífero, etc) passam a apresentar esta
propriedade e, por transitividade, as subclasses destas classes também passam a fazê-lo.
O resultado deste mecanismo de herança de propriedades é que um objeto da classe Cão,
por exemplo, inclue em seu comportamento peculiar as ações olhar e mamar, além de outras
ações bem particulares que estarão descritas diretamente na classe Cão.
- 19 -
POLIMORFISMO
•
É a capacidade de tratarmos objetos de diferentes tipos de uma mesma maneira desde que
eles tenham um ancestral em comum
•
Objetos de classes diferentes podem ter métodos com mesmo nome e cada objeto
responderá adequadamente de acordo com seu método.
•
Métodos da mesma classe podem ter o mesmo nome, desde que possuam quantidade ou
tipo de parâmetros diferentes.
•
Métodos da classe derivada podem ter nomes iguais aos da classe base, inclusive com
parâmetros iguais.
Em linguagem estruturada:
Abstração da figura em uma definição de tipo: registro variante ou estrutura com um campo que
discrimina entre os diferentes tipos de figuras
PROCEDURE Display (umaFigura: Figura);
BEGIN
CASE umaFigura.figuraTipo OF
Triangulo: MostrarTriangulo (umaFigura.Triangulo)
Retangulo: MostrarRetangulo (umaFigura.Retangulo)
Quadrado: MostrarQuadrado (umaFigura.Quadrado)
Circulo: MostrarCirculo (umaFigura.Circulo)
END
END
- 20 -
Em linguagem OO com ligação dinâmica:
Implementar um método para cada figura, mas o mesmo nome pode ser usado para cada uma
delas.
Não é responsabilidade do usuário determinar o método correto a ser invocado.
Vantagens:
•
Sobrecarga de nomes
•
Mais adaptável à mudança
•
Uso de código reutilizável genérico
- 21 -
MÉTODO
Um grupo de instruções em uma classe, que define como os objetos da classe se
comportarão. Os métodos são semelhantes a funções em outras linguagens, mas sempre precisam
estar localizados dentro de uma classe.
•
Método de classe: Um método que opera em uma classe isoladamente, e não em
instancia específicas de uma classe.
•
Método de instância: Um método de um objeto que opera sobre este objeto manipulando
os valores de suas variáveis de instancia. Como os métodos de instância são muito mais
comuns do que os métodos de classe, eles normalmente são chamados apenas de
métodos.
- 22 -
CLASSES E OBJETOS
Uma classe é uma definição para um tipo de entidade da mesma maneira como uma
entrada em um dicionário é uma descrição de um tipo de entidade, como um carro. Um objeto é
uma abstração para uma única entidade, como seu carro. Uma classe define regras. Um objeto
define fatos. Um objeto é instanciado (criado) de acordo com as regras definidas por sua classe.
É um tipo de dado, como os já conhecidos, para declarar variáveis.
Uma variável de uma classe é chamada de Objeto.
Definir uma classe não cria um objeto, assim como um tipo de variável NÃO é uma
variável.
•
Variáveis de Classe: São os dados declarados em uma classe
•
Instância: Temos uma instância de uma classe quando declaramos um objeto a partir de
uma classe. É semelhante à declaração de uma variável.
MODELAGEM DE DADOS
Do desenho de sistemas de informação, a modelagem de dados consiste em desenhar o
sistema de informações, concentrando-se nas entidades lógicas e nas dependências lógicas entre
essas entidades.
Na fase inicial do desenvolvimento de um projeto de software, a ênfase será no desenho
de um modelo conceitual. Este pode ser detalhado em um modelo lógico dos dados às vezes
chamado de modelo de dados funcional. Em estágios posteriores, o modelo pode ser traduzido no
modelo físico.
- 23 -
REUTILIZAÇÃO
A capacidade de se otimizar a produtividade do programador depende diretamente da
maneira como o software disponibiliza a reutilização do código gerado. De fato, a maioria dos
programadores profissionais, já reutiliza código anteriormente gerado, porém a perfeita
reutilização consiste na utilização COMPLETA de um código gerado para algum sistema SEM
qualquer outra adaptação prévia.
Quatro requerimentos de software reutilizável
Os fatores importantes em reutilização de software são plenamente conhecidos há muito tempo.
Esses fatores são:
•
Documentação - deve haver informação adequada sobre o que cada componente de
software reutilizável pode fazer.
•
Flexibilidade - um componente verdadeiramente reutilizável deve ser aplicável em mais
de um contexto.
•
Visibilidade - para reutilizar software, os desenvolvedores devem poder encontrar os
componentes a reutilizar (em um catálogo de componentes reutilizáveis, por exemplo).
•
Eficiência - um componente de reutilizável não será utilizado se não tiver a eficiência
requerida pelo programa de aplicação.
- 24 -
BIOGRAFIA
CHAGAS JUNIOR, WALTER ALVES. O QUE É ORIENTAÇÃO À OBJETOS ?,
Belo Horizonte, [s.n.], Jun. 2001. Disponível em:
<http://www.geocities.com/SiliconValley/Bay/1058/oop.html>. Acesso em: mar. 2005.
Conceitos de Orientação a Objetos, [S.I.], [s.n.]. Disponível em:
<http://groups.msn.com/cafedotnet/conceitosdeorientaoaobjetos.msnw>. Acesso em:
mar. 2005
DELPHI Orientação a Objetos + Object Pascal , [S.I.], [s.n.]. Disponível em:
<http://www.firstsoft.com.br/curso/delphi_avancado1.htm >. Acesso em: mar. 2005.
HARADA, ELAINE TEIXEIRA DE OLIVEIRA. Orientação a Objetos - Uma
Introdução à Programação Orientada a Objetos – DCC – ICE - UFAM, 2004, [S.I.],
[s.n.]. Disponível em: <http://www.dcc.ufam.edu.br/~elaine/>. Acesso em: mar. 2005.
LIMA, BRUNO R. Orientação a Objetos e Java Na Prática Minicurso : Entendendo
orientação a objetos e aplicando-a na linguagem Java em um exemplo prático, São
Paulo, Conexão Java, Ago. 2004. Disponível em:
<http://www.conexaojava.com.br/conexaojava04/download/minicursos/OO.e.Java.na.pra
tica-Conexao.Java.2004.pdf>. Acesso em: mar. 2005.
Modelagem de dados, [S.I.], [s.n.]. Disponível em:
<http://pt.wikipedia.org/wiki/Modelagem_de_dados>. Acesso em: mar. 2005
Pequeno dicionário básico de orientação a objetos em Java, São Paulo, Linha de
código, Ago. 2004. Disponível em:
<http://www.linhadecodigo.com.br/artigos.asp?id_ac=95> . Acesso em: mar. 2005.
Programação Orientada a Objetos - LSC / INF / UFSC, Santa Catarina, [s.n.].
Disponível em <http://www.inf.ufsc.br/poo>. Acesso em: mar. 2005.
SEBESTA, ROBERT W. Conceitos de Linguagens de Programação / Robert W.
Sebesta; trad. José Carlos Barbosa dos Santos. – 5. ed. – Porto Alegre: Bookman, 2003.