Apply access modifiers

Em Java, os modificadores de acesso são palavras-chave que determinam a visibilidade de classes, métodos e campos em relação a outras classes. Existem quatro principais modificadores de acesso: public, protected, default (sem modificador) e private. Vamos explorar como esses modificadores são aplicados:

Modificadores de Acesso em Classes:

  1. public (Público):
  • Uma classe declarada como public é visível para todas as outras classes, independentemente do pacote.
   public class MinhaClasse {
       // ...
   }
  1. default (Sem Modificador):
  • Se nenhuma palavra-chave de modificação de acesso for usada, a classe é considerada com acesso de pacote (default). Isso significa que a classe só é visível dentro do mesmo pacote.
   class MinhaClasse {
       // ...
   }

Modificadores de Acesso em Campos e Métodos:

  1. public:
  • Um campo ou método declarado como public é acessível de qualquer lugar.
   public class MinhaClasse {
       public int meuCampo;
       public void meuMetodo() {
           // ...
       }
   }
  1. protected:
  • Campos e métodos marcados como protected são visíveis para a própria classe, classes do mesmo pacote e classes filhas (subclasses), mesmo que estejam em pacotes diferentes.
   class MinhaClasse {
       protected int meuCampoProtegido;
       protected void meuMetodoProtegido() {
           // ...
       }
   }
  1. default (Sem Modificador):
  • Campos e métodos sem modificador de acesso (default) são visíveis apenas dentro do mesmo pacote.
   class MinhaClasse {
       int meuCampoDefault;
       void meuMetodoDefault() {
           // ...
       }
   }
  1. private:
  • Campos e métodos marcados como private são visíveis apenas dentro da própria classe.
   class MinhaClasse {
       private int meuCampoPrivado;
       private void meuMetodoPrivado() {
           // ...
       }
   }

Exemplo Completo:

// Pacote A
public class ClassePublicaA {
    // Campos e métodos públicos
    public int campoPublicoA;
    public void metodoPublicoA() {
        // ...
    }

    // Campos e métodos com modificador de acesso padrão (default)
    int campoDefaultA;
    void metodoDefaultA() {
        // ...
    }

    // Campos e métodos protegidos
    protected int campoProtegidoA;
    protected void metodoProtegidoA() {
        // ...
    }

    // Campos e métodos privados
    private int campoPrivadoA;
    private void metodoPrivadoA() {
        // ...
    }
}

// Pacote B
class ClasseDefaultB {
    // Campos e métodos com modificador de acesso padrão (default)
    int campoDefaultB;
    void metodoDefaultB() {
        // ...
    }
}

// Pacote C
class ClasseProtegidaC extends ClassePublicaA {
    // Campos e métodos protegidos (herdados da ClassePublicaA)
    void acessarCamposEMetodosProtegidos() {
        campoProtegidoA = 42;
        metodoProtegidoA();
    }
}

// Pacote D
class ClassePrivadaD {
    // Campos e métodos privados
    private int campoPrivadoD;
    private void metodoPrivadoD() {
        // ...
    }
}

Neste exemplo, diferentes classes estão em pacotes diferentes, e os modificadores de acesso são utilizados para controlar a visibilidade dos campos e métodos entre essas classes.