Programação Orientada a Objetos parte 2

PROGRAMAÇÃO
ORIENTADA A OBJETOS –
Parte 2
03/06/2016Prof.ªM.ªEng.ªElaineCecíliaGatto
DesenvolvimentodeSoftwarepareaWeb2016

Encapsulamento
• Permite dividir o programa em partes
menores e independentes
• Cada parte realiza seu trabalho
independentemente das outras partes
• Oculta detalhes internos através de uma
interface externa

Encapsulamento
• É a característica da OO de ocultar partes
independentes da implementação
• Permite que o programador construa
partes ocultas da implementação do
software, que atinjam uma funcionalidade
e ocultam os detalhes de implementação
do mundo exterior

Encapsulamento
• Encapsulamento é como uma caixa preta
• Sabe-se o que a caixa preta faz, mas não
se sabe como ela é por dentro
• As mensagens são enviadas para a caixa
preta
• Não há preocupação com o que acontece
dentro dela, desde que ela funcione, tudo

Interface
• Lista os serviços fornecidos por um
componente
• É um contrato com o mundo exterior, que
define exatamente o que uma entidade
externa pode fazer com o objeto
• É o painel de controle do objeto
• Lista todos os métodos e argumentos que

Interface
• Diz o que o programador pode fazer com
o componente
• Não informa como o componente fará seu
trabalho
• Oculta a implementação
• Alterações na Interface necessitarão de
mudanças no código que exerce essa

Implementação
• Define como um componente realmente
fornece um serviço
• Define os detalhes internos do
componente

Interface Pública
• São os comportamentos disponíveis, em
uma classe, para o mundo exterior.
• EXEMPLO (próximo slide)

Interface Pública
public class Log {
public void debug ( String message ){
System.out.print(“DEBUG”, message);
}
public void info ( String message ){
System.out.print(“INFO”, message);
}
public void warning ( String message ){
}
}

Interface Pública
public class Log {
}
}
}
}
COMPORTAMENTOS
OU MÉTODOS

Interface Pública
public class Log {
}
}
}
}
INTERFACES PÚBLICAS
public void debug ( String message )
public void info ( String message )
public void warning ( String message )

Interface Pública
public class Log {
}
}
}
}
IMPLEMENTAÇÃO

Interface e Implementação
• Implementação: define como algo é feito
• Interface:
– Oculta o como
– Define um contrato com o mundo exterior
• EXEMPLO: a interface pública, ou o
comportamento, ou ainda o MÉTODO, public void
debug (String message) é uma maneira de dizer ao
mundo exterior que, se o programador passar uma
String, ela reportará uma mensagem de depuração!

Interface
• Utilidade: definir o que uma classe deve
fazer mas não como ela o fará;
• Definição: um conjunto de métodos que
será implementado por uma classe;
• Uma interface não fornece implementação
dos métodos que define

Interface
• Uma interface apenas especifica o que
deve ser feito, mas não como;
• Uma interface é uma estrutura que
descreve a funcionalidade sem especificar
uma implementação;

Interface
• SINTAXE:
public interface nome{
método1;
método2;
...
...
...
}

Interface
• Declarar as interfaces preferencialmente
como public para que um número ainda
maior de classes possa implementá-la
• Métodos da classe interface: possuem
apenas a assinatura e o tipo de retorno

Interface
• Nenhum método da interface deve ser
implementado;
• Cada classe que implementa a interface
deve fazer a sua própria implementação
dos métodos;
• Os métodos da interface são públicos
implicitamente

Exemplo 1: Implementando uma
Interface
• Sintaxe:
class nome_da_classe implements
interface{ }
• Ou ainda
class nome_da_classe extends superclasse
implements interface{ }

Interface
• É permitido que uma classe que
implemente uma interface, defina seus
próprios membros e métodos;
• Ela não fica limitada a fornecer apenas
esses métodos, mas é obrigada a
implementá-los também

Interfacce
• Uma ou mais classes diferentes podem
implementar a mesma interface
• Essas classes podem ser usadas da
mesma maneira, inclusive

Exemplo 4: Referencias de
Interface
• Uma declaração de interface também cria
um novo tipo de referência;
• Quando uma classe implementa uma
interface, está adicionando o tipo da
interface ao seu tipo;
• Uma instância de uma classe que
implementa uma interface também é uma
instância desse tipo de interface

Interface
• Uma variável de referencia de um tipo de interface
pode ser criada;
• Variável de referencia de interface:
– Pode referenciar qualquer objeto que implemente a
interface;
– Pode referenciar qualquer instância de seu tipo;
– Não pode ser usada para acessar nenhuma outra
variável ou método fornecido por uma classe
implementadora

Interface
• Funcionalidades relacionadas podem ser
acessadas por intermédio de uma interface
comum
• A implementação pode mudar sem afetar o
código que usa a interface
• Códigos adaptáveis facilmente

Exemplo 5: Implementando
Várias Interfaces
• Uma classe pode implementar mais de uma
interface
• A classe deve implementar todos os métodos de
todas as interfaces
• Esse recurso permite que a classe forneça
várias funcionalidades bem definidas sem ter
que usar herança de classes

Exemplo 6: Constantes
• Interfaces podem fazer uso de CONSTANTES e
não de variáveis de instâncias (atributos da classe)
• Para isso usa-se public, static e final e todas elas
devem ser inicializadas;
• USO: um programa grande usa várias classes
separadas, é preciso então haver uma maneira
conveniente de disponibilizar essas constantes para
cada classe

Exemplo 6: Constantes
• Para definir um conjunto de constantes
compartilhadas, é necessário criar uma interface
apenas com as constantes, sem os métodos;
• As classes que precisarem de acesso às
constantes deverão apenas implementar esta
interface

Exemplo 7: Herança de
Interface
• Uma interface pode herdar outra com o uso da
palavra-chave extends.
• Quando uma classe implementa uma interface
que herda outra interface, deve fornecer
implementações de todos os métodos definidos
dentro da cadeia de herança das interfaces.
• Toda e qualquer classe que implemente uma
interface deve implementar todos os métodos
definidos por ela, inclusive os herdados de

Exemplo 8: Interfaces
Aninhadas
• Uma interface pode ser declarada membro de
outra interface ou de uma classe.
• Uma interface aninhada em uma classe pode
usar qualquer modificador de acesso e é
implicitamente pública;

A. POR QUE ENCAPSULAR
• Encapsulamento transforma OBJETOS
em COMPONENTES PLUGÁVEIS
• Para um objeto usar esse componente
plugável, ele só precisa saber como usar
a interface publica do componente
• Isso significa independência

• VANTAGENS:
– Reutilização do objeto em qualquer parte do
programa
– Objetos encapsulados não estão vinculados a
nenhuma parte do programa em particular
– Para usar o objeto encapsulado basta exercer
sua interface

• VANTAGENS:
– As alterações em seu objeto se tornam
transparentes
– Permite que o programador atualize seu
componente, faça uma implementação mais
eficiente, corrija erros, etc.
– Os clientes do objeto serão automaticamente
beneficiados das alterações

• Principais características do encapsulamento
1. Abstração
2. Ocultação da implementação
3. Divisão de responsabilidade

1. ABSTRAÇÃO
• É o processo de simplificar um problema
difícil
• Simplifica-se o problema incluindo apenas as
partes que realmente afetam o contexto
• Portanto, trata-se apenas dos detalhes
pertinentes àquela situação em particular
• A abstração pode tornar um componente
encapsulado mais reutilizável, pois ele está
personalizado para um domínio de

1. ABSTRAÇÃO
• Vantagens:
– Permite que o programador resolva um
problema facilmente
– Ajuda a obter reutilização
– Permite que o programador resolve um
problema uma vez e depois use essa solução
por todo o domínio desse problema

1. ABSTRAÇÃO
• Exemplos:
– Uma fila de banco
– Produção de lanches fast food
• Os exemplos são específicos, mas é possível
encontrar uma descrição genérica para eles,
isto é, abstrair o contexto
• Nos dois exemplos, uma FIFO é utilizada para
organizar a fila do banco e também a produção,
portanto, a FIFO é a abstração

1. ABSTRAÇÃO
• Regras para se obter abstração
– Tratar do caso GERAL e não do específico
– Quando confrontar diversos problemas
diferentes, procure o problema comum a todos
– Procurar ver um conceito e não um caso
específico
– A abstração pode não aparecer tão facilmente
quanto você espera.
• Regras geral
– Abstrair algo que você tiver implementado três

1. ABSTRAÇÃO
• Cuidados em relação à Abstração
– Trate a abstração como um bônus e não como
objetivo final
– Existem ocasiões em que a abstração não é
apropriada
– Talvez você tenha de resolver um problema
várias vezes para conseguir identificar que ali
cabe uma abstração
– Resolva o que precisa ser resolvido, não invista
muito tempo tentando abstrair algo que não
consegue ou que, de fato, não é necessário.

2. OCULTANDO
IMPLEMENTAÇÃO
• Ocultar implementações internas de seus
objetos
• Vantagens:
I. Protege o objeto de seus clientes
II. Protege os clientes de seu objeto do próprio
objeto

I. PROTEGENDO SEU OBJETO
COM ABSTRACT DATA TYPE
• Abstract Data Type
• Possuem duas características: abstração e tipo
• É um conjunto de dados e um conjunto de operações
sobre esses dados
• Permitem definir novos tipos na linguagem, que são
seguros de usar, ocultando dados internos e o estado,
atrás de uma interface bem definida
• São ferramentas de encapsulamento
• Uma vez definido o novo tipo, o programador o usa
como qualquer outro tipo definido na linguagem

• Um objeto de primeira classe é aquele
que pode ser usado exatamente da
mesma maneira que um tipo inteiro
• Um objeto de segunda classe é um tipo de
objeto que você pode definir, mas não
necessariamente usar, como faria um tipo
interno.

• EXEMPLO: TIPOS DE DADOS
• Quando você soma dois números inteiros,
você não pensa a respeito da adição de
bits individuais, você pensa na adição dos
dois números, não se preocupa em como
o computador faz isso.

• EXEMPLO DE ABSTRAÇÃO: Construir um
programa para somar dois números inteiros
– O programador não pensa na soma de bits
individuais
– A linguagem apresenta um inteiro como um
número

• EXEMPLOS DE ABSTRAÇÃO: A criação de um
novo objeto de uma classe
– O programador não pensa nos atributos como
uma entidade separada do objeto

• PORTANTO:
• Tipos de dados permitem representar estruturas
complexas em um nível mais simples e
conceitual
• Tipos de dados “protegem” o programador dos
detalhes desnecessários
• Tipos de dados permitem aos programadores
trabalhar no nível do problema

• Ao projetar um TAD, perguntar-se: o que faz
esse TAD?
• Exemplo: FIFO
– O que uma FIFO faz?
• Coloca e remove elementos na fila
• Consulta o estado da fila
• Visualiza o elemento

• Ao projetar um TAD, perguntar-se: o que faz
esse TAD?
• Exemplo: FIFO
– Interface para FIFO
public interface FIFO {
public void inserir ();
public void remover ();
public boolean vazia();
public void visualizar();
}
• Não diz nada a respeito de
como a fila contém seus
dados internos
• Novo tipo de dados: FIFO
• Interface FIFO extremamente
genérica. Não é uma FIFO de
hamburgers, nem de inteiros.

• PORTANTO:
• Quando o programador declara uma variável do
tipo INT, o significado é simples: o programador
declarou um único inteiro.
• MAS, quando o programador declara FIFO, esta
é muito mais EXPRESSIVA. Mais coisas estão
ocorrendo dentro de FIFO do que dentro de INT.

II. PROTEGENDO OS CLIENTES
DE SEUS OBJETOS
• CÓDIGO FRACAMENTE ACOPLADO:
– É independente da implementação de outros
componentes
– Mais flexível: facilita reutilização e aprimoramento
• CÓDIGO FORTEMENTE ACOPLADO:
– É fortemente vinculado à implementação de outros
componentes
– Anula o objetivo do encapsulamento que é criar
objetos independentes e reutilizáveis
– Elimina a liberdade do programador de alterar a

DE SEUS OBJETOS
• OCULTAÇÃO DE IMPLEMENTAÇÃO:
– impede que os clientes de seus objetos se
tornem fortemente acoplados
– dessa maneira protege seus objetos e os
clientes dos seus objetos.
• IMPORTANTE:
– Caso seja necessário realizar alterações na sua
INTERFACE, o código que é dependente desta
Interface necessitará ser atualizado também!

DE SEUS OBJETOS
• CÓDIGO DEPENDENTE:
– Depende da existência de um determinado
tipo.
– É inevitável
– Graus de dependência:
• Dependência aceitável
• Superdependência
• Interfaces bem definidas diminuem a

DE SEUS OBJETOS
• Problemas na Ocultação da Implementação:
– Um programador A usa uma Interface que foi
desenvolvida por um programador B
– O programador A precisa de mais informações
sobre como a Interface funciona, para
desenvolver seu componente adequadamente
– DOCUMENTAR como sua a Interface funciona
é IMPORTANTE para quem for utiliza-la!
– Um comportamento declarado na Interface não
pode ser alterado, mas pode ser INFORMADO!

3. Divisão da
Responsabilidade
• Cada objeto deve executar uma função
(responsabilidade) e executá-la bem
• Todas as funções devem trabalhar no
sentido de uma responsabilidade comum
• Os objetos devem ter um ou um pequeno
número de responsabilidades

3. Divisão da
Responsabilidade
• Um objeto deve saber como fazer seu
trabalho
• Quando dois objetos começam a fazer a
mesma tarefa, o programador se dá conta
de que não foi feita a divisão correta da
responsabilidade. Consequência: código
procedural
• Cuidado com a Redundância!

3. Divisão da
Responsabilidade
• Muitas responsabilidades em um objeto
resulta em:
– Implementação difícil e confusa
– Muitos comportamentos
– Centraliza muito conhecimento
– Pode tornar-se procedural
– Pode tornar-se um programa completo
– Pode tornar-se “desencapsulado”

3. Divisão da
Responsabilidade
• Encapsulamento efetivo: abstração + ocultação +
responsabilidade
• Sem abstração o código pode não ser reutilizável
• Sem ocultação o código pode tornar-se fortemente
acoplado
• Sem responsabilidade o código fica centrado nos
dados, procedural, fortemente acoplado,
descentralizado, tornando a programação procedural
em um ambiente orientado a objetos

CONCLUSÕES
• É impossível escrever uma classe que satisfaça
todos os usuários e cada situação.
• Não coloque em uma classe mais do que o
necessário para resolver o problema
• Ao escrever uma classe, tente não trabalhar de
forma abstrata demais
• Algum elemento na sua abstração pode não
funcionar em todos os casos

CONCLUSÕES
• Quanto mais responsabilidade um objeto assume,
mais complexo, mais complexo ele será e mais
difícil será mantê-lo
• Adicionar uma classe em seu sistema é o mesmo
que criar um novo tipo
• A abstração aparece com a experiência
• TAD não tem herança ou polimorfismo, diferente
das classes que os tem

CONCLUSÕES
• O que deve estar na Interface pública?
– Apenas o que você pretende que outros usem
• Sempre ocultar as variáveis internas (exceto
constantes) e deixa-las acessíveis apenas para a
própria classe
• A abstração permite que o programador pense e
programe no geral
• Cada componente pode ser validado
individualmente (testes unitários)

CONCLUSÕES
• A abstração fornece código flexível e utilizável em
mais de uma situação
• Código encapsulado é fácil de dar manutenção
• Alterações podem ser feitas sem danificar código
dependente
• O código que usar o componente será atualizado
automaticamente

CONCLUSÕES
• Dividindo o problema em partes, vários
desenvolvedores podem trabalhar no
desenvolvimento do software, cada um com uma
parte
• Componente criado e validado, está pronto para
reutilização.

Programação Orientada a Objetos parte 2

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Programação Orientada a Objetos parte 2

Semelhante a Programação Orientada a Objetos parte 2 (20)

Mais de Elaine Cecília Gatto

Mais de Elaine Cecília Gatto (20)

Último

Último (20)

Programação Orientada a Objetos parte 2