Aula 6

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Aula 6: Encapsulamento e Associações de Classes
Encapsulamento: Mecanismo utilizado na Programação Orientada a 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.
Conclusão: 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 e permite apenas acesso através de métodos públicos
Modificadores de Visibilidade: Um modificador de acesso determina como será a visibilidade de uma classe, método ou atributo a partir de outras classes.
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.
Sem Encapsulamento: 
class NaoEncapsulado {
//implicitamentamente há modificador de acesso, mas não é o mais restritivo
            int semProteção;
}
 
public class TesteNaoEncapsulado {
           public static void main(String[] args) {
                   NãoEncapsulado ne = new NãoEncapsulado(); 
                   //ne é uma instância de NãoEncapsulado
                   ne.semProtecao = 10; //acesso direto ao atributo
                   System.out.println("Valor sem proteção: " + ne.semProteção); //acesso direto aos atributos
           }
}
Com Encapsulamento:
class Encapsulado {
          //private é um modificador de acesso de restrição máxima
          private int comProteção;
          public void setComProteção(int comProteção) {
                       this.comProteção= comProteção;
          }
          public int getComProteção () {
                       return this.comProteção;
          }
}
 
public class TesteEncapsulado {
           public static void main(String[] args) {
                  Encapsulado e = new Encapsulado(); 
                  // O Objeto "e" é uma instância de Encapsulado
 
                  e.comProteção = 10;
                 //deve-se acessar o atributos de forma indireta, encapsulada
                 e.setComProteção (10);
                 System.out.println("Valor com proteção: " + e.getComProteção ());
           }
} 
Métodos Get’s e Set’s
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>.
Abaixo vemos um exemplo de atributo que não permite alteração, logo seus atributos são privados e só foi disponibilizado os métodos get’s.
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.
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);
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); 
            } 
}
Podemos ter as seguintes multiplicidades de associações:
1 para 1
1 para *
* para *
Onde * equivale a muitos.