A Java-ban a hozzáférés-módosítók alapvető eszközök, amelyek meghatározzák, hogy egy osztály tagjai, például a változók metódusai, sőt maga az osztály hogyan érhető el programunk más részeiből.

A Java-ban 4 típusú hozzáférés-módosító érhető el: 

Privát hozzáférés módosító

A privát hozzáférés módosítója a private kulcsszóval van megadva. A privátként deklarált metódusok vagy adattagok csak abban az osztályban érhetők el, amelyben deklarálták őket.

   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  

Magyarázat: A névhez való közvetlen hozzáférés a beágyazást végrehajtó személyen kívül nem engedélyezett.

Alapértelmezett hozzáférés-módosító

Ha nincs hozzáférésmódosító megadva egy osztálymetódushoz vagy adattaghoz, akkor a rendszer alapértelmezés szerint rendelkezik az alapértelmezett hozzáférés-módosítóval. Ez azt jelenti, hogy csak az azonos csomagon belüli osztályok férhetnek hozzá.

   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  

Magyarázat: Az alapértelmezett hozzáféréssel rendelkező tagok nem érhetők el más csomagban lévő osztályokból.

Geeks.java: Alapértelmezett osztály ugyanazon a csomagon belül

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

GeeksNew.java: Alapértelmezett osztály egy másik csomagból (a kontraszt kedvéért)

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

Magyarázat:  Ebben a példában a program megmutatja a fordítási idő hibát, amikor egy másik csomagból próbálunk elérni egy alapértelmezett módosító osztályt.

Védett hozzáférés-módosító

A védett hozzáférés módosító a védett kulcsszóval van megadva. A védettnek nyilvánított metódusok vagy adattagok ugyanazon a csomagon vagy alosztályokon belül, különböző csomagokban érhetők el.

   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  

Magyarázat: speed elérhető alosztály metódusokon és más osztályokon keresztül ugyanabban a csomagban, de a közvetlen hozzáférés egy másik csomagból (nem alosztály) meghiúsulna.

Nyilvános hozzáférés módosító

A nyilvános hozzáférés módosító a public kulcsszóval adható meg. A nyilvános tagok a programban mindenhonnan elérhetők. A nyilvános adattagok köre nincs korlátozva.

   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  

Magyarázat: Az add() globálisan elérhető a nyilvános módosítónak köszönhetően.

A legfelső szintű osztályok vagy interfészek nem deklarálhatók privátként, mert a privát azt jelenti, hogy „csak a körülvevő osztályon belül látható”.

A Java hozzáférés-módosítóinak összehasonlító táblázata

Mikor kell használni az egyes hozzáférés-módosítókat a valós projektekben

• Magán: Az ötletnek a lehető legkorlátozóbb hozzáférést kell használnia, így a lehető legnagyobb mértékben a privát hozzáférést kell használni.
• Alapértelmezett (Package-Private): Gyakran használják a csomag-hatókörű segédprogramokban vagy segédosztályokban.
• Védett: Általánosan használt öröklés alapú tervekben, például keretkiterjesztésekben.
• Nyilvános : Ez az API-végpontok szolgáltatásosztályaihoz vagy az alkalmazás különböző részei között megosztott segédprogram-metódusokhoz használatos.