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.