POO Encapsulamento

Programação Orientada a Objetos

Encapsulamento
Pacotes e Modificadores de Acesso

Ludimila Monjardim Casagrande
2012

Aplicação de Modificadores de Acesso

 Esse exemplo apresenta uma classe modelada
em UML na qual existe um atributo privado e
dois métodos públicos:

- private
+ public
# protected
~ default

Encapsulamento ©2012 Ludimila Monjardim Casagrande 2

O Conceito de Pacote

 Em Java, a visibilidade ou grau de acesso a um
atributo ou método está intimamente ligado ao
conceito de pacote ou simplesmente package.

 A identificação de uma package corresponde à
hierarquia de diretórios na qual a classe está
inserida.
 Exemplo de declaração de package:
 package br.com.salesiano;  Raiz do projeto.



 Em um código-fonte escrito em Java, a declaração da
package deve sempre anteceder a declaração da
classe.
 Normalmente a declaração da package é a primeira
informação contida no arquivo.
 Na composição do nome da package os nomes dos
diretórios devem ser separados por “.”.
 Deve-se ter cuidado para que os nomes dos diretórios
que compõem uma package sejam nomes válidos para
todas as plataformas.



package br.com.salesiano;

public class Conta {
private double saldo;
public void creditar (double valor) {
saldo = saldo + valor;
} Classe contida
public void debitar (double valor) { no subdiretório
saldo = saldo - valor; salesiano.
}
}


Importações

 Para fazer uso de uma package em uma classe
é necessário importá-la.
 A sintaxe para importação é:
 import <pkg_name>[.<sub_pkg_name>].<class_name>;
 import <pkg_name>[.<sub_pkg_name>].*;
 É possível importar uma única classe, usando o nome da
package seguido do nome da classe, ou importar toda
uma package, usando o nome da package com um
asterisco no final.


Pacotes e Importações nas Classes

 A estrutura básica de um arquivo-fonte em Java
deve ser:
 Declaração da package
 Importações (imports)
 Definição da(s) classe(s)

 Essa ordem é relevante, portanto, deve ser
respeitada.


Exemplo: Entrada.java
package br.com;

import java.util.Scanner;
//import java.util.*; //também poderia ser usado

public class Entrada{
public static void main(String[] args){

Scanner entrada = new Scanner(System.in);
String nome;

System.out.println("Informe seu nome: ");
nome = entrada.next();

System.out.println("Seu nome é: " + nome);
} * Requer J2SDK 1.5 ou
} superior

Modificadores de Acesso

 Os modificadores de acesso definem quais
classes podem usar ou ter acesso a um
determinado elemento.

 Esses elementos podem ser:
 Uma classe;
 As variáveis de uma classe (atributos);
 Os métodos e os construtores de uma classe.


Modificadores de Acesso

 Em Java, os modificadores de acesso são:
 public
 protected
 private

 O modificador de acesso considerado “default”
corresponde à ausência de qualquer um dos
modificadores citados.


O Modificador: Public

 O modificador de acesso public é aquele que
permite o maior grau de visibilidade e de acesso
aos diferentes elementos.

 Classes, variáveis de classes, construtores e
métodos declarados como públicos podem ser
usados sem restrições.

 Public pode ser aplicado a qualquer um dos
elementos citados.


O Modificador: Private

 O modificador private é o mais restritivo de
todos.
 Variáveis ou métodos declarados como private
só podem ser acessados diretamente por
instâncias da classe a qual pertencem.
 Nem mesmo subclasses possuem acesso direto
a elementos declarados como private na sua
superclasse.
 O modificador private não se aplica a classes.


O Modificador: Protected

 Os elementos declarados como protected
podem ser acessados por classes da mesma
package ou pelas subclasses da classe na qual
estão contidos.
 Esse modificador não se aplica a classes.
 É aplicado normalmente a variáveis e métodos.
 Elementos declarados como protegidos
possuem um grau de acesso maior do que os
declarados como “default”.


Ausência de Modificador de Acesso

 A ausência de um modificador de acesso na declaração
de um elemento indica um grau de acessibilidade
considerado “default”.
 Esse grau de acessibilidade é mais restritivo do que o
protected uma vez que torna os elementos visíveis
somente para a própria classe e para as outras classes
contidas na mesma package.
 Os elementos declarados com “default” não podem ser
usados pelas subclasses da classe na qual estão
contidos, caso essas pertençam a outras packages.


Modificadores e Membros da Classe

 A tabela indica a quais elementos da classe os
vários modificadores de acesso podem ser
aplicados:
Classe Atributos Construtores Métodos
public sim sim sim sim
protected não sim sim* sim
default sim sim sim sim
private não sim sim* sim

* Pouco utilizado nesses casos.


Níveis de Acesso

 A tabela indica os níveis de acesso (ou graus de
visibilidade) definidos por cada modificador de
acesso:
Classe Package Subclasse* Global**
public sim sim sim sim
protected sim sim sim não
default sim sim não não
private sim não não não

* Subclasse contida em outra package.
** Acesso por classes de outros projetos ou sistemas.


Possível Distribuição de Classes
Packages:


Encapsulamento

 Encapsulamento é um dos conceitos
fundamentais da programação orientada a
objetos.
 O encapsulamento, também referido como
ocultamento de informações, consiste em
separar os aspectos externos de um objeto, os
quais são acessíveis a outros objetos, dos
detalhes internos de sua implementação, os
quais permanecem ocultos para os outros
objetos.


Principais Vantagens

 O uso de encapsulamento permite que a
implementação de um objeto possa ser
modificada sem afetar as aplicações que usam
este objeto, ou seja, o encapsulamento evita
que um programa se torne tão interdependente
que uma pequena mudança tenha grandes
efeitos colaterais.


Principais Vantagens

 O encapsulamento também evita que dados
específicos de uma classe possam ser
acessados ou usados diretamente e faz com
que isso aconteça somente por meio das
operações cuja responsabilidade é a
manipulação desses dados.
 Tais operações são consideradas a interface
dos objetos, que permite a comunicação entre
os mesmos.


Exemplo
public class Hora {
public int hora;
Atributos declarados como
public int minuto;
públicos
public int segundo;
public Hora() {
}
public Hora(int h, int m, int s) {
this.hora = h;
this.minuto = m; Falha no construtor!
this.segundo = s;
} A classe é
responsável por
public String toString( ) {
manter a
String str = hora + ":" + minuto + ":" + segundo; consistência e
return str; correção das suas
} instâncias.
}

Exemplo

public class Principal {
public static void main (String[] args) {
Hora h = new Hora();
h.hora = 30; Como os atributos são públicos, eles
h.minuto = 80; podem ser acessados e alterados
h.segundo = -40; diretamente em outra classe
System.out.println(h);
}
}

Resultado: 30:80:-40  Não é uma hora válida!


Solução para o Problema

 Usar encapsulamento para controlar os valores
atribuídos às variáveis da classe, de forma que
a todo momento os dados mantidos pela classe
sejam válidos e consistentes.

 Uma classe deve conhecer quais são os valores
válidos para os seus atributos. As demais
classes não são obrigadas a saber esses
detalhes.


public class Hora {
private int hora;
private int minuto;
public void setHora(int hora) {
private int segundo;
if(hora >= 0 && hora <= 23) {
public Hora(){ this.hora = hora;
} }
public Hora(int h, int m, int s) { }
if((h >= 0 && h <= 23) && public void setMinuto(int minuto) {
(m >= 0 && m <= 59) && if(minuto >= 0 && minuto <= 59) {
(s >= 0 && s <= 59)) { this.minuto = minuto;
this.hora = h; }
this.minuto = m; }
this.segundo = s;
public void setSegundo(int segundo) {
}
if(segundo >= 0 && segundo <= 59) {
}
this.segundo = segundo;
public String toString( ) { }
String str = hora + ":" + minuto + ":" + segundo; }
return str; …
} }
…


public static void main (String[] args) {
Hora h = new Hora();
h.setHora(30);
h.setMinuto(80);
h.setSegundo(-40);
System.out.println(h);
}
}

Resultado: 0:0:0  Tentativas de alterações inválidas não são aceitas.


Ocultamento de Implementação

public static void main (String[ ] args) {
Incrementa5 inc = new Incrementa5();
int resultado = inc.incrementa5(10);
System.out.println(resultado);
}
}

Resultado: 15


Ocultamento de Implementação
public class Incrementa5 {

/*public int incrementa5 (int numero) {
int i = 0;
while (i < 5) {
numero++; As implementações podem
i++; ser substituídas sem efeitos
} colaterais para as classes
return numero; que utilizam o método.
}*/

public int incrementa5 (int numero) {
return numero + 5;
}
}


Leituras Recomendadas

 FJ-11: Java e Orientação a Objetos.
Caelum Ensino e Soluções em Java.
http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos/

 Java: Como Programar.
Autores: H. M. Deitel e P. J. Deitel.
Editora: Pearson – 6ª Edição.


POO Encapsulamento

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (11)

Semelhante a POO Encapsulamento

Semelhante a POO Encapsulamento (20)

Mais de Ludimila Monjardim Casagrande

Mais de Ludimila Monjardim Casagrande (14)

POO Encapsulamento