Modificadores Java

Modicadores de Acesso

  1- public = Todas as outras classes podem acessar.
  2- default (implícito em situações onde nenhum outro é inserido, não pode ser escrito no código) = Apenas outras classes do mesmo pacote podem acessar.
  3- protected = Todas as classes do mesmo pacote ou de sub-classes podem ver.
  4- private = Somente a própria classe pode ver.

- Interfaces:

  Para interfaces: public ou sem nenhum (implicitamente public).
  Para atributos e métodos de interfaces: public ou sem nenhum (implicitamente public).

- Classes:

  Para classes: public ou sem nenhum (implicitamente default).

  Para atributos e métodos de classes: public, protected, private ou sem nenhum (implicitamente default).

- Métodos e argumentros:

  Variáveis locais e argumentos de métodos não podem usar modificadores de acesso.

===========================================
package primeiro;
public class ClassePublica{

public int intPublic = 0;
int intDefault = 1;
protected int intProtected = 2;
private int intPrivate = 3;

}
===========================================
package primeiro;
import primeiro.ClassePublica;
public class ClasseTesteModificadorAcesso extends ClassePublica {

int testePublic = intPublic;
int testeProtected = intProtected; // pela herança a classe atual tem acesso aos membros protected da super classe, mesmo estando em pacote diferente.
int testeDefault = intDefault; // pode ser visto por classes de dentro do mesmo pacote
// int testePrivate = intPrivate; // menbros private só podem ser vistos na própria classe

public static void main (String [] args){
ClassePublica classePublica = new ClassePublica();
classePublica.intPublic = 11;
classePublica.intDefault = 22; //é visível aqui, está dentro do próprio pacote
classePublica.intProtected = 33; //é visível aqui, está dentro do próprio pacote. OBS: em instâncias, protected é igual a default.
// classePublica.intPrivate = 44; //não é visível aqui, somente dentro da própria classe
}

}
==========================================
package segundo;
import primeiro.ClassePublica;
public class ClasseTesteModificadorAcesso extends ClassePublica {

int testePublic = intPublic;
int testeProtected = intProtected; // pela herança a classe atual tem acesso aos membros protected da super classe, mesmo estando em pacote diferente.
// int testeDefault = intDefault; // membros default só podem vistos dentro do mesmo pacote
// int testePrivate = intPrivate; // menbros private só podem ser vistos na própria classe

public static void main (String [] args){
ClassePublica classePublica = new ClassePublica();
classePublica.intPublic = 11;
// classePublica.intDefault = 22; //não é visível aqui, somente dentro do próprio pacote
// classePublica.intProtected = 33; //não é visível aqui, somente dentro do próprio pacote, em instâncias protected é igual a default, ou seja, não pode ser visto em pacote diferentes.
// classePublica.intPrivate = 44; //não é visível aqui, somente dentro da própria classe
}

}

=======================================

Outros Modificadores (Exceto Modicadores de Acesso)

- Final

  Esse modificador significa que ao ser marcado:
  Classes: Não podem ser extendidas. OBS.: Interfaces e classes abstract não podem receber esse modificador.
  Métodos: Não podem ser sobrescritos.
  Variáveis de instância, variáveis locais e argumentos de método: Não podem ter suas referências alteradas, ou seja, não podem apontar para um novo objeto. Somente alterar o próprio objeto referenciado. No caso de primitivos(int, double, etc...) nenhuma alteração é possível, nem de valor.

- Abstract

  Toda interface é implicitamente abstract.
  Classes podem ser abstract. Isso implica que não pode ser instânciada. Deve ser extendida para ser usada.
  Métodos podem ser abstract. Se uma classe possui pelo menos um método abstract, a classe também deve ser marcada com abstract. E qualquer subclasse concreta dela deve implementar todos os métodos abstract, ou seja, sem implimentação.
  O modificador abstract não pode ser usado juntamente com os modificadores final e private.

- Synchronized

  Esse modificador só pode ser usado em métodos.
  Significa que o método marcado só pode ser acessado por uma Thread de cada vez.

- Native

  Só pode ser aplicado a métodos.
  Um método native não deve ter corpo, ou seja, terminar com (;) ponto e vírgula.

- Strictfp

  Somente classe e métodos podem usar esse modificador.
  Significa que seus ponto flutuates não são dependentes de plataforma. Eles obdeceram ao padrão IEEE 754.

- Transient

  Significa que a variável não será serializada no caso no objeto que a contenha seja serializado. Ou seja, ao deserializar o objeto esse valor será perdido.
  Só pode ser usado em variáveis de instância.

- Volatile

  Só pode ser usado em variáveis de instância.