În Java, modificatorii de acces sunt instrumente esențiale care definesc modul în care membrii unei clase precum metodele variabilelor și chiar clasa în sine pot fi accesate din alte părți ale programului nostru.

Există 4 tipuri de modificatori de acces disponibile în Java: 

Modificator de acces privat

Modificatorul de acces privat este specificat folosind cuvântul cheie privat. Metodele sau membrii datelor declarați ca private sunt accesibile numai în cadrul clasei în care sunt declarați.

   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ţie: Accesul direct la nume nu este permis în afara Persoanei care impune încapsularea.

Modificator de acces implicit

Când nu este specificat nici un modificator de acces pentru o metodă de clasă sau un membru de date, se spune că are modificatorul de acces implicit în mod implicit. Aceasta înseamnă că numai clasele din același pachet îl pot accesa.

   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ţie: Membrii cu acces implicit nu pot fi accesați din clase dintr-un pachet diferit.

Geeks.java: Clasa implicită în același pachet

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

GeeksNew.java: Clasa implicită dintr-un pachet diferit (pentru contrast)

   // 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ţie:  În acest exemplu, programul va afișa eroarea de compilare atunci când încercăm să accesăm o clasă modificatoare implicită dintr-un pachet diferit.

Modificator de acces protejat

Modificatorul de acces protejat este specificat folosind cuvântul cheie protected. Metodele sau membrii datelor declarați ca protejați sunt accesibile în cadrul aceluiași pachet sau subclase în pachete diferite.

   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ţie: viteza este accesibilă prin metode de subclasă și alte clase din același pachet, dar accesul direct dintr-un pachet diferit (non-subclasă) ar eșua.

Modificator de acces public

Modificatorul de acces public este specificat folosind cuvântul cheie public. Membrii publici sunt accesibili de oriunde în program. Nu există nicio restricție privind sfera de aplicare a membrilor datelor publice.

   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ţie: add() este accesibil la nivel global datorită modificatorului public.

Clasele sau interfețele de nivel superior nu pot fi declarate ca private, deoarece private înseamnă „vizibile doar în cadrul clasei care le înconjoară”.

Tabel de comparație a modificatorilor de acces în Java

Când să utilizați fiecare modificator de acces în proiectele din lumea reală

• Privat: Ideea ar trebui să fie folosirea accesului cât mai restrictiv posibil, astfel încât privatul să fie folosit cât mai mult posibil.
• Implicit (Pachet-Privat): Adesea folosit în utilități sau clase de ajutor pentru pachet.
• Protejat: Folosit în mod obișnuit în proiectele bazate pe moștenire, cum ar fi extensiile de cadru.
• Public : Acesta este utilizat pentru clasele de servicii ale punctelor finale API sau metodele utilitare partajate în diferite părți ale unei aplicații.