Em Java, modificadores de acesso são ferramentas essenciais que definem como os membros de uma classe, como métodos de variáveis ​​e até mesmo a própria classe, podem ser acessados ​​de outras partes do nosso programa.

Existem 4 tipos de modificadores de acesso disponíveis em Java: 

Modificador de acesso privado

O modificador de acesso privado é especificado usando a palavra-chave private. Os métodos ou membros de dados declarados como privados são acessíveis apenas na classe em que são declarados.

   class   Person     {      // private variable      private     String     name  ;      public     void     setName  (  String     name  )     {      this  .  name     =     name  ;     // accessible within class      }      public     String     getName  ()     {     return     name  ;     }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      Person     p     =     new     Person  ();      p  .  setName  (  'Alice'  );      // System.out.println(p.name); // Error: 'name'      // has private access      System  .  out  .  println  (  p  .  getName  ());      }   }   

Alice  

Explicação: O acesso direto ao nome não é permitido fora da Pessoa que impõe o encapsulamento.

Modificador de acesso padrão

Quando nenhum modificador de acesso é especificado para um método de classe ou membro de dados, diz-se que ele tem o modificador de acesso padrão. Isso significa que apenas classes do mesmo pacote podem acessá-lo.

   class   Car     {      String     model  ;     // default access   }   public     class   Main     {          public     static     void     main  (  String  []     args  ){          Car     c     =     new     Car  ();      c  .  model     =     'Tesla'  ;     // accessible within the same package      System  .  out  .  println  (  c  .  model  );      }   }   

Tesla  

Explicação: Membros com acesso padrão não podem ser acessados ​​a partir de classes em um pacote diferente.

Geeks.java: Classe padrão dentro do mesmo pacote

   // default access modifier    package     p1  ;      // Class Geek is having    // Default access modifier    class   Geek      {         void     display  ()         {         System  .  out  .  println  (  'Hello World!'  );         }      }   

GeeksNew.java: Classe padrão de um pacote diferente (para contraste)

   // package with default modifier    package     p2  ;      import     p1  .  *  ;     // importing package p1   // This class is having    // default access modifier    class     GeekNew     {         public     static     void     main  (  String     args  [])     {             // Accessing class Geek from package p1       Geek     o     =     new     Geek  ();         o  .  display  ();         }      }   

Explicação:  Neste exemplo, o programa mostrará o erro em tempo de compilação quando tentarmos acessar uma classe modificadora padrão de um pacote diferente.

Modificador de acesso protegido

O modificador de acesso protegido é especificado usando a palavra-chave protected. Os métodos ou membros de dados declarados como protegidos são acessíveis no mesmo pacote ou subclasses em pacotes diferentes.

   class   Vehicle     {      protected     int     speed  ;     // protected member   }   class   Bike     extends     Vehicle     {      void     setSpeed  (  int     s  )      {      speed     =     s  ;     // accessible in subclass      }      int     getSpeed  ()      {      return     speed  ;     // accessible in subclass      }   }   public     class   Main     {      public     static     void     main  (  String  []     args  ){          Bike     b     =     new     Bike  ();      b  .  setSpeed  (  100  );      System  .  out  .  println  (  'Access via subclass method: '      +     b  .  getSpeed  ());      Vehicle     v     =     new     Vehicle  ();      System  .  out  .  println  (  v  .  speed  );      }   }   

Access via subclass method: 100 0  

Explicação: speed é acessível através de métodos de subclasse e outras classes no mesmo pacote, mas o acesso direto de um pacote diferente (não subclasse) falharia.

Modificador de acesso público

O modificador de acesso público é especificado usando a palavra-chave public. Os membros públicos são acessíveis de qualquer lugar do programa. Não há restrição quanto ao escopo dos membros de dados públicos.

   class   MathUtils     {             public     static     int     add  (  int     a       int     b  )     {      return     a     +     b  ;      }   }   public     class   Main     {          public     static     void     main  (  String  []     args  )     {          System  .  out  .  println  (  MathUtils  .  add  (  5       10  ));     // accessible anywhere      }   }   

15  

Explicação: add() é acessível globalmente devido ao modificador público.

Classes ou interfaces de nível superior não podem ser declaradas como privadas porque privado significa 'visível apenas dentro da classe envolvente'.

Tabela de comparação de modificadores de acesso em Java

Quando usar cada modificador de acesso em projetos do mundo real

• Privado: A ideia deve ser usar o acesso o mais restritivo possível, de modo que o acesso privado seja usado tanto quanto possível.
• Padrão (Package-Private): Frequentemente usado em utilitários com escopo de pacote ou classes auxiliares.
• Protegido: Comumente usado em designs baseados em herança, como extensões de estrutura.
• Público : isso é usado para classes de serviço de terminais de API ou métodos utilitários compartilhados em diferentes partes de um aplicativo.