Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
*
*
Linguagem de Programação
EDUARDO LUIZ PARETO
Rio de Janeiro, 19 de setembro de 2011
*
Aula 6
Encapsulamento e Associações de Classes
Objetivos
Apresentar os conceitos de Encapsulamento e Associações de Classes
Criar e manipular classes com seus atributos Encapsulados e que se relacionem através de Associações
*
*
Encapsulamento
Mecanismo utilizado na Programação Orientada à Objetos que visa obter segurança, modularidade e autonomia para os objetos;
Conseguido através da definição de visibilidade privada dos atributos, ganhando-se assim autonomia para definir o que o mundo externo a classe poderá visualizar e acessar, normalmente através de métodos públicos.
*
*
*
Concluindo
Sempre defina os atributos de uma classe como privados, a não ser que tenha uma boa justificativa para isso.
O Encapsulamento protege os atributos de acesso direto
Permite apenas acesso através de métodos públicos
*
*
*
Modificadores de Visibilidade
Modificadores de Acesso: public, protected, private e sem modificador (default)
Modificadores de Não Acesso: final e abstract
public – Atributos e métodos são acessíveis em todos os métodos de todas as classes. Este é o nível menos rígido de encapsulamento, que dizemos que o encapsulamento foi rompido.
private - Atributos e métodos são acessíveis somente nos métodos da própria classe. Este é o nível mais rígido de encapsulamento.
protected - Atributos e métodos são acessíveis no pacote, nos métodos da própria classe e suas subclasses.
Sem Modificador – A visibilidade nas classes do mesmo pacote e a própria classe.
*
*
*
Tabela de Visibilidades
*
*
*
Outros Modificadores
abstract – Um método abstrato não implementa nenhuma funcionalidade, somente assina o método e faz com que a primeira subclasse concreta seja obrigada a implementar. Uma classe que possui um método abstrato deve ser obrigatoriamente abstrata, como vimos na aula passada.
final – Pode ser aplicado em classes, métodos e atributos. Indica que esta é a última atribuição ou definição da estrutura. Não será permitida uma nova re-escrita. Para uma classe, não há herança em classes final. Um método não pode ser sobrescrito. E um atributo é considerado uma constante.
static – Um método ou atributo estático define que este pode ser executado sem que exista uma instância da classe – o objeto.
*
*
*
Exemplo: sem encapsulamento
class NaoEncapsulado {
//implicitamentamente há modificador de acesso,
//mas não é o mais restritivo
int semProtecao;
}
public class TesteNaoEncapsulado {
public static void main(String[] args) {
NaoEncapsulado ne = new NaoEncapsulado();
//ne é uma instância de NaoEncapsulado
ne.semProtecao = 10; //acesso direto ao atributo
System.out.println("Valor sem proteção: " + ne.semProtecao);
//acesso direto aos atributos
}
}
*
*
*
Exemplo: com encapsulamento
class Encapsulado {
//private é um modificador de acesso de restrição máxima
private int comProtecao;
public void setComProtecao(int comProtecao) {
this.comProtecao = comProtecao;
}
public int getComProtecao() {
return this.comProtecao;
}
}
public class TesteEncapsulado {
public static void main(String[] args) {
Encapsulado e = new Encapsulado();
// O Objeto "e" é uma instância de Encapsulado
e.comProtecao = 10; //Esta linha dá erro
e.setComProtecao(10);
System.out.println("Valor com proteção: " + e.getComProtecao() );
}
}
*
*
*
Métodos Get’s e Set’s
Como vimos, é preciso criar um mecanismo para acessar os campos private de uma classe. Para isso, é comum fornecer métodos públicos para acessar as informações encapsuladas. Estes métodos são chamados de set e get. O método set atribui valores ao atributo, enquanto que o método get obtém seus valores.
A composição do nome destes métodos é sempre com o nome set + <nome atributo> ou get + <nome atributo>.
*
*
*
Exemplo
*
*
*
Exercício
*
A partir da classe Automovel.java apresentada abaixo, encapsule seus métodos e crie mecanismos públicos para acessar estas características.
Crie mais um atributo na classe do tipo boolean – estadoMotor
Crie métodos ligarMotor() e desligarMotor(), atualizando o valor de estadoMotor.
Crie uma classe de teste para instanciar Automóvel
Automovel.java
public class Automovel {
String modelo, cor;
int ano;
}
*
*
Associação de Classes
*
É um vínculo que permite que objetos de uma ou mais classes se relacionem. Através destes vínculos, é possível que um objeto troque mensagens ou chame os métodos de outros objetos.
Na UML, quando estamos modelando o diagrama de classes, temos a Associação, a Composição e a Agregação, como tipos de Associações.
As Associações têm acoplamento fraco
As Composições têm acoplamento forte
A Agregação faz parte de.
Na implementação, não há diferença entre as abordagens, o que as distingue são os controles adicionados pelo desenvolvedor.
*
*
Exemplo
public class Aviao {
Motor motor = new Motor(); // composição - O Avião é composto de Motor
public void adiciona(Passageiro p){ // isto é agregação
p.embarque(this);
}
public void remove(Passageiro p){
p.desembarque(this)
}
// isto é uma associação
public void setControladorVoo (ControladorVoo controlador);
public ControladorVoo getControladorVoo ();
}
*
*
*
Exemplo
public class Passageiro {
Aviao aviao ;
public void embarque(Aviao aviao ){
if (this.aviao ==null){
throw new IllegalStateException("O passageiro já embarcou. Remova-o antes de o incluir em outro");
}
this.aviao = aviao ;
}
public void desembarque(Aviao aviao){
if (aviao.equals(this.aviao)){
this.aviao = null;
}
}
}
*
*
*
Composição
*
Tipo de associação onde uma nova classe usa classes existentes como atributos;
Relacionamento “tem um”.
Ex.:
uma conta tem um dono (cliente),
um cliente tem um nome (string);
*
*
Exemplo - Composição
class Aleatorio {
int numero;
Aleatorio(int max) {
numero = new Random().nextInt(max); }
}
public class NumeroAleatorio {
private String nome;
private Aleatorio valor;
NumeroAleatorio(String nome, int valor) {
this.nome = nome;
this.valor = new Aleatorio(valor); }
public static void main(String[] args) {
NumeroAleatorio n;
n = new NumeroAleatorio("Número secreto", 50);
}
}
*
*
*
Multiplicidade de Associações
*
Podemos ter as seguintes multiplicidades de associações:
1 para 1
1 para *
* para *
Onde * equivale a muitos.
*
*
Exemplos de Associações
*
Um automóvel tem um motor instalado
public class Carro {
private String modelo;
private short ano;
private Motor motor; // Atributo gerado pela associação
public void Carro(short a, String mod, Motor m){
this.modelo = mod;
this.ano = a;
this.motor = m;
}
}
*
*
Exemplos de Associações (cont)
*
public class Motor {
private String combustivel;
private float potencia;
public void Motor(float pot, String comb){
this.potencia = pot;
this.combustivel = comb;
}
}
public class TestaCarro {
public static void main(String[] args) {
Motor motFusca = new Motor(999f, “gasolina”);
Carro fusca82 = new Carro(“Fusca”,(short)1982, motFusca);
Carro kombi2010 = new Carro(“Kombi”,(short)2010, new Motor(1399f,”flex”));
}
}
*
*
Fim!
*
*
AULA 1
AULA 1
*
AULA 1
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1
AULA 1
*
AULA 1