En Java los modificadores de acceso son herramientas esenciales que definen cómo a los miembros de una clase les gustan los métodos variables e incluso se puede acceder a la clase misma desde otras partes de nuestro programa.

Hay 4 tipos de modificadores de acceso disponibles en Java: 

Modificador de acceso privado

El modificador de acceso privado se especifica mediante la palabra clave privado. Los métodos o miembros de datos declarados como privados sólo son accesibles dentro de la clase en la que están 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  

Explicación: No se permite el acceso directo al nombre fuera de la Persona que aplica la encapsulación.

Modificador de acceso predeterminado

Cuando no se especifica ningún modificador de acceso para un método de clase o miembro de datos, se dice que tiene el modificador de acceso predeterminado de forma predeterminada. Esto significa que sólo las clases dentro del mismo paquete pueden acceder a él.

   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  

Explicación: No se puede acceder a los miembros con acceso predeterminado desde clases en un paquete diferente.

Frikis.java: Clase predeterminada dentro del mismo paquete

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

GeeksNew.java: Clase predeterminada de un paquete diferente (para contrastar)

   // 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  ();         }      }   

Explicación:  En este ejemplo, el programa mostrará el error en tiempo de compilación cuando intentemos acceder a una clase modificadora predeterminada desde un paquete diferente.

Modificador de acceso protegido

El modificador de acceso protegido se especifica utilizando la palabra clave protected. Los métodos o miembros de datos declarados como protegidos son accesibles dentro del mismo paquete o subclases en diferentes paquetes.

   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  

Explicación: Se puede acceder a la velocidad a través de métodos de subclase y otras clases en el mismo paquete, pero el acceso directo desde un paquete diferente (que no sea de subclase) fallaría.

Modificador de acceso público

El modificador de acceso público se especifica mediante la palabra clave public. Se puede acceder a los miembros públicos desde cualquier lugar del programa. No hay restricciones en el alcance de los miembros de datos 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  

Explicación: add() es accesible globalmente debido al modificador público.

Las clases o interfaces de nivel superior no se pueden declarar como privadas porque privado significa "solo visible dentro de la clase adjunta".

Tabla comparativa de modificadores de acceso en Java

Cuándo utilizar cada modificador de acceso en proyectos del mundo real

• Privado: La idea debería ser utilizar un acceso lo más restrictivo posible, por lo que se debería utilizar lo privado tanto como sea posible.
• Por defecto (Paquete privado): se utiliza a menudo en utilidades con ámbito de paquete o clases auxiliares.
• Protegido: Comúnmente utilizado en diseños basados ​​en herencia, como extensiones de marco.
• Público : se utiliza para clases de servicios de puntos finales de API o métodos de utilidad compartidos en diferentes partes de una aplicación.