poo - Computação UFCG

============================
BACHARELADO EM
CIÊNCIA DA COMPUTAÇÃO
============================
DISCIPLINA: Sistemas de Informação II
PROFESSOR: Ulrich Schiel
CONTEÚDO
1) Linguagens de Programação: gerações
2) Linguagens de Programação: paradigmas
3) Linguagens de Programação: programação orientada a
objetos
4) Orientação a Objetos - Conceitos e sistemas
(Bancos de Dados, Interfaces, Sistemas Operacionais, linguagens...)
5) A Linguagem Unificada de Modelagem - UML
5) Análise e projeto de sistemas orientados a objetos
(O Processo Unificado - RUP-Rational Unified Process)
BIBLIOGRAFIA
Jacobson, I., Booch, G., Rumbaugh, J. The Unified Software
Development Process
Booch, Grady / Rumbaugh, James / Jacobson, Ivar Uml - Guia Do
Usuario Editora Campus
Booch, Grady / Rumbaugh, James / Jacobson, Ivar Uml - Guia Do
Programador Editora Campus
C. Larman Utilizando UML e Padrões- Uma Introdução à Análise e ao
Projeto Orientados a Objeto, Bookman (2000)
B. COX Object-Oriented Programming: An Evolutionary Approch, Addison
Wesley, 1986
J.D. FURLAN Modelagem de objetos através da UML, Makron Books, 1998
J. MARTIN Fourth Generation Languages, Prentice Hall, 1985
R. SEBESTA Concepts of Programming Languages, Benjamin Cummings,
1989
R. SETHI Programmin Languages – Concepts and Constructs, 2nd Edition,
Addison Wesley, 1996
2
1) Linguagens de Programação: gerações
1ª GERAÇÃO - programação física, linguagens de máquina
0010 0010 0001 0011 1000 0100 0010 0001 0001 0010 0101 0100 1000 0110
2ª GERAÇÃO - Linguagens de baixo nível (Assembly, Autocoder)
CLA
ADD
STO
CLA
ADD
DIV
STO
C
D
Y
A
B
Y
X
3ª GERAÇÃO - Linguagens de alto nível
Científicas - FORTRAN, Algol
Comerciais - COBOL
Universais - PL/I, ADA
Sistemas - Pascal, Modula 2, C, C++, Java
Especiais - SIMULA, LISP, SNOBOL, PROLOG, APL, RPG
4ª GERAÇÃO - O que no lugar do como (MANTIS, NATURAL,
IDEAL, SQL, QBE)
Incrementa/substitue comandos sequenciais por
 Formulários, interação por janelas, Gráficos
 Linguagens não-procedurais
 Geradores de aplicações
 Prototipagem
 Sistemas de Suporte a Decisão,
 Linguagens para aplicações específicas (finanças, robótica,
CAD, pesquisa textual, etc.)
3
2) Linguagens de Programação: paradigmas
 COMPLETAS (Máquinas de Turing) - Pascal, COBOL, C,....
 INCOMPLETAS (SQL, QBE)
 EXTENDIDAS (goto, ON, acesso a registradores, FORMAT,
PICTURE, acesso direto, auto-modificação)
 PROCEDURAIS (IMPERATIVAS)
Programa principal: seqüência de comandos e
ações
 ORIENTADAS A OBJETOS
Coleção de objetos que recebem mensagens
Linguagens: Simula, SmallTalk, Eiffel, Oberon
 FUNCIONAIS
Interpretador de expressões: Execução de funções
Exemplo LISP:
FATORIAL: (LAMBDA(N)
(COND(EQUAL N 1) 1)(T(TIMES N (FATORIAL(SUB 1 N))))))
 LÓGICAS
Interpretador de expressões: verificação de
relações
um programa consiste de fatos e regras Ex PROLOG
Casamento de padrões: SNOBOL
 COMBINAÇÕES:
Imperativo+OO: ObjectPascal, TurboPascal, Modula 3,
ObjectiveC, C++, Java
4
Funcional + OO: ObjectLisp, CLO
Lógico + OO: ObjLog
 NÃO-PROCEDURAL (NOMAD, SQL, QBE, APL, RPG, L4G)
LINEAR X BIDIMENSIONAL
(monólogo X diálogo)
LINGUAGENS DE FLUXO DE DADOS (DFD, HIPO, RPG)
5
PROTOTIPAGEM
TIPOS DE APLICAÇÕES
Computação pré-especificada
(programação convencional)
J.Martin
Computação dirigida pelo usuário
(prototipagem)
Burns & Dennis
ciclo-devida
mista
complexidade
prototipagem
incerteza
6
prototipagem
Protótipos
 modelo vivo
 testes de hipóteses (de dados, relatórios, telas)
 testes de arquitetura
 “quick and dirty” (rápido e ruim)
Usuário
Problemas
Analista
Testes, uso
Construção
revisão
Protótipo
7
PROTOTIPAGEM X CICLO-DE-VIDA
(=eXtreme Programming ??)
Análise de
requisitos
Projeto
Implementação
Testes
Manutenção
ciclo de vida
tempo
Análise de
requisitos
Projeto
Implementação
Testes
Manutenção
prototipagem
8
CONTEÚDO DE UM PROTÓTIPO
1) Definição Lógica
 Relatórios
 Telas
 Informações
 Funções
 Controles
 Interface
2) Definição física
 Banco de dados
 fluxo do sistema
9
TIPOS DE PROTOTIPAGEM
s
u = usuário
p = projetista
s = software
h = hardware
u
h
p
 Exploratória (usp) - prototipagem rápida
 Experimental (psh)
 Evolutiva (usph)
 Desempenho (uph)
 Organizacional (ush)
10
METODOLOGIAS DE PROTOTIPAGEM
1) Prototipagem evolutiva
1. exame de viabilidade do projeto
2. identificação dos requisitos
3. desenvolvimento do modelo vivo
4. demonstração e uso
5. revisão e melhoramentos
6. utilização
7. repetir 3-6 acima até terminar
B) Prototipagem descartável
1-5 acima
6. elaboração do sistema real
C) Prototipagem fundamental
1-5 acima
6. elaboração da documentação e implementação
D) Prototipagem aplicada ao ciclo-de-vida
11
PROTOTIPAGEM
EVOLUTIVA
PROTOTIPAGEM
FUNDAMENTAL
PROTOTIPAGEM
DESCARTÁVEL
Exame de
viabilidade
Levantamento
dos requisitos
Desenvolvimento
do protótipo
Documentação
e teste
Revisão
Codificação e
teste porgramas
Elaboração
documentação
Testes
integrados
Produto final
Incorporação
esquemas
segurança
Implantação
12
Documentação
Implantação
3) Linguagens de Programação: programação
orientada a objetos
ORIENTAÇÃO A OBJETOS:

Programação OO

Linguagens OO

Projeto OO

Sistemas OO

Bancos de Dados OO

Interfaces OO

Ambientes OO
Paradigma da Orientação a Objetos:
No mundo existem
- Objetos (com estrutura e comportamento)
- Mensagens entre objetos
- Nada mais
Novos paradigmas de software:
 Frameworks
 componentes
13
Por que POO ?
Crise de Software
Problemas:
reusabilidade, capacidade de um programa em ser
aproveitado para uma outra aplicação, semelhante à
original;
adaptabilidade, capacidade de um programa em se
adaptar a novas situações novas;
extensibilidade, capacidade de um programa em ser
estendido incorporando novas funcionalidades.
Prevenção de alterações
- Linha Maginot: A assinatura do cliente proíbe alterações.
Boa documentação, comentários e linguagem de alto nível
não são suficientes.
- Defesa suiça: Prototipagem, mudanças fazem parte vital do
processo de desenvolvimento do sistema (ex. Smalltalk, Engª do
conhecimento)
Problemas: Eficiência, controle, compatibilidade (com sistemas
existentes).
14
Sistemas devem ser:
- maleáveis e elásticos em tempo de execução
=> acoplagem dinâmica (dynamic binding)
- alteráveis e extensíveis
=> encapsulamento e hereditariedade
- evitar efeitos colaterais.
=> encapsulamento (objeto = caixa preta)
A POO enfatiza a relação entre produtor e consumidor de
software.
desenvolvimento convencional
desenvolvimento O.O.
consumidor -> produtor <-> código
consumidor <-----> produtor


______________________
FOCO EM SISTEMA
Programa




____objetos ______
FOCO EM OBJETO
Classe
Processos
Atributos
Dados
Operações
15
Um dos objetivos da POO é reduzir a
superfície de software
O que influi na superfície de software:
1) Encobrimento da informação (encapsulamento, variáveis
locais, etc.) reduz a superfície de software
2) Tipos Abstratos de Dados. Quanto mais concreto o dado,
mais informação é necessária para especificar os argumentos
de uma função. Reduz a superfície de software
3) Seqüência/paralelismo de operações: uma seqüência fixa
aumenta a superfície;
4) “Garbage collection: A necessidade de reservar e liberar
explicitamente os objetos, aumenta a superfície de software;
5) Domínios protegidos: uma estação de trabalho ou um
processo, são domínios relativamente protegidos. Comunicam
entre si por arquivos e mensagens. Reduz a superfície de
software
6) Concorrência: Problemas concorrentes aumentam a
superfície, pois a comunicação ocorre em duas dimensões:
tempo e espaço.
16
Origens da POO:
- Tipos abstratos de dados
Sintaxe
(interface)
Especificação
Semântica
(axiomas)
Tipos abstratos
de Dados
Implementação
Representação
Procedimentos
EXEMPLO:
Os números inteiros:
Sintaxe: Elementos: 0, 1, 2, 3, ..9, 10, 11,...
Operações: +, -, *, 
Semântica:
0 N
Função de criação p: N  N
sendo N = {0, p(0), p(p(0)), p(p(p(0))), ...} = {0, 1, 2, 3, 4, ..}
 n  N (n+ 0 = n  n + 1 = p(n))
Representação:
números binários limitados
Procedimentos:
aritmética computacional de inteiros
17
- Bancos de Dados (modelos semânticos de dados - abstrações)
generalização-(herança);
agregação;
agrupamento
EXEMPLO:
FAMILIA
HOMEM
PESSOA
MULHER
FILHOS
- Inteligência Artificial
- (frames, modelos de atores, redes semânticas, ontologias)
18
Principais características da Programação
Orientada a Objetos
1) Objetos e Classes
Um objeto é uma unidade identificável e distinguível de outros
objetos.
Objetos são compostos por
- uma identificação;
- uma estrutura, (atributos e relacionamentos) e
- um comportamento (métodos e regras de integridade).
h1
casar-com(m1)
m1
casado-com
nome: 'João'
estado-civil
casar-com(h1)
casar-com(m)
divorciar-se-de(m)
nome: 'Maria'
estado-civil
casar-com(h)
divorciar-se-de(h)
Objetos são os únicos elementos primários de uma aplicação.
Se comunicam entre si trocando mensagens.
19
CLASSIFICAÇÃO
Uma classe é a descrição das características de uma coleção de
objetos semelhantes.
HOMEM
nome:STRING
estado-civil:INTEGER
casar-com(m)
divorciar-se-de(m)
20
2) Encapsulamento
O usuário de um objeto (consumidor) somente vê a sintaxe da
especificação, que são os nomes do métodos de acesso ao objeto.
novo
Elem
empilha
estrutura
dos dados
topo
desempilha
consumidor
produtor/fornecedor
3) Objetos complexos, objetos compostos
AUTOMÓVEL = (MOTOR, CARROCERIA, ESTOFAMENTO)
CARROCERIA = ({RODA}, BASE, CARCAÇA, INTERIOR)
AUTOMÓVEL
MOTOR
CARROCERIA
ESTOFAMENTO
4
RODA
21
4) Hierarquias de generalização: classes com
herança
 Fatoração de dados e procedimentos
VEICULO
tamanho
ambiente
VEICULO
TERRESTRE
VEICULO
PEQUENO
VEICULO
AÉREO
VEICULO
MEDIO
VEICULO
GRANDE
VEICULO
AQUATICO
NAVIO
22
5) Polimorfismo (Amarração dinâmica)
EXEMPLO: Sistema de automação de escritório, com objetos
Calendário, Arquivo, Envelope, mesa, Clipe, CaixaES, ListaDePreços,..
Na CaixaES haverá um método que processa um ítem colocado na caixa.
código não reusável
item = nextItemInCaixa();
switch(item  type)
{ case ListaPreços opLiP();
case Envelope opEnv();
.}
código reusável
item = nextItemInCaixa();
[item opItem];
6) Identificação de objetos
x=y
xy
OO = TAD + Herança [ + Identificação ]
TAD = Estrutura + Comportamento [ + Restrições }
Comportamento = Especificação + Implementação
Herança = herança estrutural + herança comportamental
23
TÉCNICAS DE EMPACOTAMENTO E COMUNICAÇÃO
1) Canais e filtros UNIX
Alta reusabilidade de pequenos pacotes. Comunicação primitiva (bytes)
2) Biblioteca de subroutinas
Comunicação com estruturas complexas, mas fortemente tipadas.
3) Objetos (CIs de software)
Comunicação com estruturas complexas, parametrizadas. Polimorfismo.
Exemplo: Contagem do número de palavras de um texto dado, sem
repetições
Canais e Filtros
tr -cs ‘A-Za-z0-9’ ‘\012’  sort -u  wc -l
POO (ObjectiveC)
palUnicas = [ Set new]
/* inicializa um conjunto vazio *?
while (getWord(buf) != EOF)
/* lê uma palavra para o buffer *?
{ palCorrente = [ByteArray str:buf]; /* palavra corr. é um array de
bytes */
[palUnicas add:palCorrente]; /* acrescente pal. corrente ao
conjunto*/
}
printf('o número de palavras únicas é %d\n', [palUnicas size]);
Programação com subrotinas (C):
100 linhas de código
24
ALGUMAS LINGUAGENS DE PROGRAMAÇÃO
ORIENTADA A OBJETOS
1) Turbo Pascal 5.5
type
Localização = object
X, Y : integer;
procedure Init(novoX, novoY:integer)
end;
Ponto = object(localização)
visível: boolean;
procedure Init(IX,IY : integer)
end
procedure Localização.Init(novoX, novoY : integer)
begin
X := novoX;
Y := novoY
end
procedure Ponto.Init(IX, IY : integer)
begin
Localização.Init(IX, IY);
visível ::= FALSE
end
var
meuPonto : Ponto;
/* alternativa 1 */
begin
with meuPonto do
X := 341;
Y := 42;
visível := FALSE
end
end
/* alternativa 2 */
begin
meuPonto.Init(341, 42)
end
25
2) Object Pascal (Delphi)
unit Localizacao;
type
TLocalizacao = class(Tform)
private
x: real;
y: real;
{protected}
public
procedure init(var a, b:real);
function getx : real;
procedure setx(var a:real);
implementation
procedure TLocalizacao.init(var a, b:real);
begin
x:= a;
y:=b;
end;
end.
unit Ponto;
uses
Localizacao;
type
TPonto = class (TLocalizacao)
private
visivel:boolean;
public
procedure init(var a, b:real); override;
implementation
procedure TPonto.init(var a, b:real);
begin
inherited init(a,b);
visivel := false;
end;
end.
...................
var p1, p2:TPonto; vx:real:
26
p1:= TPonto.create(nil);
p1.init(2,5);
vx := p1.getx
p1.free;
27
3) JAVA
Public class Location{
Float x,y;
Location(float x, float y){
This.x=x;
This.y=y;
}
}
public class Ponto extends Location{
boolean visible;
Ponto(float x, float y){
Super(x,y);
Visible=false;
}
public void setPoint(float a, float b){
x=a;
y=b;
}
CRIACAO DE UM OBJETO DO TIPO PONTO:
Ponto p = new Ponto(2,4)
 Criado um objeto p do tipo Ponto com coordenadas iniciais p(2,4)
p.setPoint(3,6)
 Modificacao dos valores antigos de p(2,4) para (3,6)
28
4) Ada
package GeometriaBidimensional is
type vector is record
x : integer; y : integer;
end record;
function “+” (a,b) : in vector) return vector;
function “-” (a,b) : in vector) return vector;
end GeometriaBidimensional;
package body GeometriaBidimensional is
function “+” (a,b) : in vector) return vector is
begin
.......código
end
function “-” (a,b) : in vector) return vector is
begin
.......código
end
with GeometriaBidimensional;
destino, origem, extensão : vector;
soma, a : integer;
......
destino = origem + extensão;
soma = a + 2;
29
5) SmallTalk
Exemplos de comandos:
agenda imprimir
index max:limite
vetor em:pos colocar:elemento /* vetor(pos) := elemento */
elemento := vetor at:pos
/* elemento := vetor(pos) */
dia + 4
cond
ifTrue[bloco A]
ifFalse{bloco B]
[i<10]
whileTrue
[ sum := sum + (a at:i)
i := i+1]
x to y do:[bloco]
100 timesRepeat:[i := i+1 . i imprimir]
30
class Ponto
superclass Object
class variables
phi
instance variables x y
class methods
novoPonto X:valorX Y:valorY ||
self new X : valorX
Y : valorY
definirPhi || phi := 3.1416
instance methods
+ outroPonto ||
Ponto novoPonto X : self.X + outroPontoX
Y : self.Y + outroPontoY
Cálculo do Fatorial:
fatorial
self = 0 ifTrue:[1].
self < 0
ifTrue [self error: ‘receptor não deve ser negativo’]
ifFalse :[self * (self-1) fatorial].
31
C++
CLASSE COM FUNÇÕES
CLASSE COM
AMIGAS
ENCAPSULAMENTO
class data {
class data {
int dia, mês, ano;
public
int dia, mês, ano;
public
friend void novaData(data*,int,int,int);
void nova(int,int,int);
friend void proxData(data*);
void prox();
friend void proxHoje();
void mostre();
friend void mostreData(data*);
}
}
main() {
main() {
data meuAniv, hoje;
data meuAniv, hoje;
int d, m, a;
int d, m, a;
get(d, m, a);
get(d, m, a);
novaData(&meuAniv, 12, 09, 1955);
meuAniv.nova(12, 09, 1955);
novaData(&hoje, d, m, a);
hoje.nova(d, m, a);
proxHoje();
hoje.prox();
32
Subclasses em C++ (classes derivadas)
class figura {
vetor centro;
int cor;
figura *prox;
public
void mova(vetor);
vetor aonde() /* retorna o local da figura */
virtual void desenhe();
};
class circulo : public figura {
float raio;
public
void rotacao(int);
void desenhe();
}
Construtores e destrutores
class string{
int comprimento;
char *bytes;
public
string(char*) /* construtor de strings */
~string() /destrutor de strings */
}
33
Questões abertas da Orientação a Objetos
1) O que é um objeto ??
estático
abstrato : números, strings, cores, salários, nomes
uma universidade, um relacionamento
concreto: pessoa, máquina, nota fiscal, uma janela
(do monitor), um prego (?), uma molécula (?)
dinâmico evento curto, evento longo, operação, transação
controle: restrição, regra de dedução, regra de produção
sem formato: fatos (‘João quebrou a perna ontem na
viagem’), textos, subtextos, imagens, etc.
intenção: esquema, subesquema, classe, contexto, categoria
2) Identificação de objetos
questão conceitual ou de implementação ??
34
3) Hierarquias de objetos
Generalização - herança conceitual X estrutural
herança múltipla
identificação
Agregação
Agrupamento



herança seletiva
4) Projeto de sistemas
projeto orientado a objetos
projeto orientado a processos
projeto orientado a controle
35
4) Sistemas orientados a objetos
 Bancos de Dados Orientados a Objetos
Os 13 mandamentos dos Bancos de Dados Orientados a
Objetos:
1. Objetos complexos (conjuntos, agregados, listas)
2. Identidade de objetos (a=b e ab)
3. Encapsulamento
4. Tipos e/ou classes (tipos  checagem; classes  extensão)
5. Hierarquias e herança
6. Polimorfismo (amarração dinâmica, sobreescrita)
7. Linguagem computacionalmente completa
8. Extensibilidade
9. Persistência
10. Sistema de gerência de arquivos
11. Concorrência
12. Recuperação
13. Ambiente de consultas
36