Modificadores de Visibilidade

A palavra-reservada private modifica a forma como as demais classes do seu

programa conseguem ver uma classe ou um atributo de classe.

Classes
Para classes, podemos ter os modificadores:

public
Todas as demais enxergam.
public class MinhaClasse { ... }

private

Somente classes no mesmo arquivo fonte enxergam. Use isso quando a

implementao serve para algum algoritmo interno da classe principal.
public class MinhaClasse {
private class MinhaClasseInternaPrivada { ... }
}
private class MinhaClassePrivada { ... }
Nota: cada arquivo .java pode ter apenas uma classe pblica.

(default)
Somente classes no mesmo arquivo fonte ou no mesmo pacote (package)
enxergam. Use quando a implementao serve apenas para sua biblioteca ou para
uma determinada parte do seu programa.
class MinhaClasse { ... }

Mtodos
Mtodos podem ter os seguintes modificadores de visibilidade:

public
Todas as classes o enxergam, desde que enxerguem a classe tambm.
public class MinhaClasse {
public void meuMetodo() { }
}

private

Somente classes no mesmo arquivo fonte enxergam. Use isso quando o mtodo
feito apenas para uso dos outros mtodos pblicos da classe.
public class MinhaClasse {
private void meuMetodoSecreto() { }
public void meuMetodoPublico() {
meuMetodoSecreto();
}
}

Mtodos privados no podem ser sobrescritos.

protected
Mtodos protegidos podem ser vistos pelas classes do mesmo pacote ou por
subclasses.
public class MinhaClasse {

protected void meuMetodo() { }

Use isso se for fazer algum tipo de biblioteca que permita a outro desenvolvedor
estender suas classes e ento usar esses mtodos especiais, os quais no devem
ser chamados por outras classes que usam a sua biblioteca.

(default)
Mtodos sem modificador podem ser vistos apenas pelas classes do mesmo
pacote.
public class MinhaClasse {
void meuMetodo() { }
}

Use isso quando um mtodo usado apenas pelas classes que compe uma parte
do seu programa.

Atributos
Atributos funcionam praticamente como os mtodos.

public
Todas as classes o enxergam, desde que enxerguem a classe tambm.
public class MinhaClasse {
public int atributo = 1;
}

uma m prtica ter atributos int, a menos que sejam "constantes" ou voc queira
simular estruturas como da linguagem C.

private
Somente classes no mesmo arquivo fonte enxergam. Procure deixar todos os seus
atributos privados e dar o acesso encasulado a eles atravs de getters e setters.
public class MinhaClasse {
private int atributo = 1;
public int getAtributo() {
return atributo;
}
public void setAtributo(int atributo) {
this.atributo = atributo;
}
}

protected

Atributos protegidos podem ser vistos pelas classes do mesmo pacote ou por
subclasses.
public class MinhaClasse {
protected int atributo = 1;
}

(default)
Atributos sem modificador podem ser vistos apenas pelas classes do mesmo
pacote.
public class MinhaClasse {
int atributo = 1;

Modificador final
usado em vrios contextos: classes, mtodos, atributos e variveis.

Classes final
Uma classe com este modificador no pode ser estendida, isto , no pode ter
classes que herdam dela.
Isso importante para garantir que uma determinada implementao no tenha
seu comportamento modificado. Isso tem muito a ver com a imutabilidade.
Tipos bsicos do Java como String e Integer so final porque se espera que o
contedo no possa ser modificado. O problema que seu algum pudesse criar
uma subclasses de String, esta implementao poderia passar a ser mutvel.
Uma String mutvel seria o caos na terra para implementaes, pois vrios
pressupostos que os desenvolvedores usam no dia-a-dia seriam simplesmente
desfeitos.
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{ ... }

Mtodo final
um mtodo que no pode ser sobrescrito nas subclasses.
Use para garantir que um determinado algoritmo no possa ser modificado pelas
subclasses.
Exemplo:
class ChessAlgorithm {
enum ChessPlayer { WHITE, BLACK }
...
final ChessPlayer getFirstPlayer() {
return ChessPlayer.WHITE;
}
...
}

Atributo final
Um atributo final de uma classe pode ter seu valor atribudo uma nica vez, seja
na prpria declarao ou no construtor.
public class MinhaClasse {
final int x = 1;
final int y;

public MinhaClasse(int y) {
this.y = y;
}
}

Use isso para garantir que um valor ou referncia de objeto no vai mudar.
Voltamos imutabilidade.
Se voc tem um algoritmo que usa esse varivel, voc pode armazenar valores
calculados sem a preocupao do valor mudar.
Exemplo:

public class MinhaClasse {

final Cliente cliente;
final BigDecimal saldo;
public MinhaClasse(Cliente cliente) {
this.cliente = cliente;
//sabemos que saldo no muda
this.saldo = cliente.chamarOperacaoComplexaQueCalculaOSaldo();
}

public BigDecimal getSaldoCliente() {

//no precisa mais recalcular toda vez
return saldo;
}

Variveis final
Use para garantir que voc no est modificando o valor indevidamente.
final boolean a = lerInputUsuario(); final boolean b = lerInputUsuario(); ... if (a =
b) //ops!!!
No cdigo acima, suponha que o desenvolvedor queria comparar os valores
de a e b, mas faltou um sinal de igual. Sem o final, haveria uma atribuio indevida
e o resultado seria o valor booleano de b. Mas como n final, o compilador vai
acusar um erro. Acabamos de impedir uma atribuio involuntria!

Threads e Classes Internas

Outra vantagem de variveis e atributos final poder us-los em classes internas,
tcnica muito usada em Threads.
public class MinhaClasse {
public void executarEmParalelo(final int limite, final Processamento proc) {
Thread t = new Thread() {
public void run() {
for (int i = 0; i < limite; i++) {
proc.executar();
}
}
};
t.start();
}
}

Modificador static
Ele muda o escopo de um mtodo ou atributo. Com o static, ao invs deles
pertencerem instncia do objeto, eles pertencem classe.
O modificador tambm pode ser aplicado para classes, como veremos a seguir.

Mtodos static
Os mtodos static podem ser chamados sem uma instncia. So timos como
utilitrios.

public final class Integer extends Number implements Comparable<Integer> {

public static Integer valueOf(String s, int radix) throws NumberFormatException {
return new Integer(parseInt(s,radix));
}
}

Voc pode chamar assim:

Integer valor = Integer.valueOf("FF", 16);

Mtodos estticos no podem acessar variveis de instncia.

public class MinhaClasse {
int valor = 1;
public static int estatico() {
return valor; //erro de compilao aqui!!!
}
}

Atributos static
Os atributos static possuem o mesmo valor para todas as instncias de um objeto
(dentro de uma mesma JVM, dentro de um mesmo ClassLoader).
public class MinhaClasse {
static int valorGlobal = 1;
public static int getValorGlobal() {
return valorGlobal;
}
}

Ento, podemos fazer o seguinte:

MinhaClasse c1 = new MinhaClasse();
MinhaClasse c2 = new MinhaClasse();
MinhaClasse.valorGlobal = 2;
System.out.println(c1); //imprime 2
System.out.println(c2); //imprime 2

Classes static
Classes static so classes declaradas dentro de outra classe que podem ser
usadas sem a necessidade de uma instncia.
public class MinhaClasse {
public static classe ClasseInterna { }
}

Ento podemos acessar isso assim:

MinhaClasse.ClasseInterna instancia = new MinhaClasse.ClasseInterna();

Juntando tudo
Agora que entendemos o que cada coisa faz individualmente, vamos a uma
aplicao prtica.

Padro de Projeto Singleton

Problema: quero garantir uma instncia nica de um objeto no meu programa.
Soluo:
public class MinhaClasse {

private static MinhaClasse instancia;

public static MinhaClasse getInstancia() {
if (instancia == null) {
intancia = new MinhaClasse();
}
return instancia;
}

Uso:
MinhaClasse instancia = MinhaClasse.getInstancia();

Isso vai retornar o mesmo valor em todas as chamadas.

Basicamente, o que fizemos foi isso:
1.

Criar um atributo chamado instancia que s a MinhaClasse pode ver

(private) e contm sempre o mesmo valor (static).
2.
Criar um mtodo que pode ser chamado diretamente pela classe, sem
precisar da instncia (static).
3.
Ento, o mtodo esttico retorna o valor esttico, que ser sempre o
mesmo.

O modificador final em variveis quer dizer que voc no pode atribuir valor duas
vezes varivel.
O modificador static quer dizer que a varivel pertence classe, no ao objeto;
isso quer dizer que todas as instncias de uma classe enxergam a mesma
varivel, e se uma delas modificar o valor, isso vai refletir em todas as outras
instncias.
Para se declarar uma constante usa-se os dois modificadores porque o mesmo
valor vai ser visto por todas as instncias da classe ( static) e nunca vai poder ser
modificado depois de inicializado (final).

Variveis que no so nem static nem final so atributos normais de um objeto, e

que portanto variam de objeto para objeto, por exemplo:
public class Pessoa {
private String nome; // ser diferente para cada objeto
...
}