In Java zijn toegangsmodifiers essentiële hulpmiddelen die definiëren hoe de leden van een klasse, zoals variabelen, methoden en zelfs de klasse zelf, toegankelijk zijn vanuit andere delen van ons programma.

Er zijn 4 soorten toegangsmodifiers beschikbaar in Java: 

Modificatie voor privétoegang

De privétoegangsmodifier wordt gespecificeerd met behulp van het sleutelwoord privé. De methoden of gegevensleden die als privé zijn gedeclareerd, zijn alleen toegankelijk binnen de klasse waarin ze zijn gedeclareerd.

   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  

Uitleg: Directe toegang tot de naam is niet toegestaan ​​buiten de persoon die de inkapseling afdwingt.

Standaardtoegangsmodificator

Als er geen toegangsmodificator is opgegeven voor een klassemethode of datalid, wordt er gezegd dat deze standaard de standaardtoegangsmodificator heeft. Dit betekent dat alleen klassen binnen hetzelfde pakket er toegang toe hebben.

   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  

Uitleg: Leden met standaardtoegang zijn niet toegankelijk vanuit klassen in een ander pakket.

Geeks.java: Standaardklasse binnen hetzelfde pakket

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

GeeksNew.java: Standaardklasse uit een ander pakket (ter 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  ();         }      }   

Uitleg:  In dit voorbeeld toont het programma de compileerfout wanneer we proberen toegang te krijgen tot een standaard modifier-klasse uit een ander pakket.

Beschermde toegangsmodificator

De beschermde toegangsmodificator wordt gespecificeerd met behulp van het sleutelwoord beschermd. De methoden of gegevensleden die als beschermd zijn gedeclareerd, zijn toegankelijk binnen hetzelfde pakket of subklassen in verschillende pakketten.

   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  

Uitleg: snelheid is toegankelijk via subklassemethoden en andere klassen in hetzelfde pakket, maar directe toegang vanuit een ander pakket (niet-subklasse) zou mislukken.

Modificatie voor openbare toegang

De openbare toegangsmodifier wordt gespecificeerd met behulp van het sleutelwoord public. Publieke leden zijn overal in het programma toegankelijk. Er is geen beperking op de reikwijdte van leden van openbare gegevens.

   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  

Uitleg: add() is wereldwijd toegankelijk dankzij de publieke modifier.

Klassen of interfaces op het hoogste niveau kunnen niet als privé worden aangemerkt, omdat privé 'alleen zichtbaar binnen de omsluitende klasse' betekent.

Vergelijkingstabel met toegangsmodificatoren in Java

Wanneer moet u elke toegangsmodifier gebruiken in echte projecten?

• Privé: Het idee moet zijn dat de toegang zo beperkend mogelijk wordt gebruikt, zodat privé zoveel mogelijk moet worden gebruikt.
• Standaard (Package-Private): Vaak gebruikt in pakketgerichte hulpprogramma's of helperklassen.
• Beschermd: Wordt vaak gebruikt in op overerving gebaseerde ontwerpen, zoals raamwerkuitbreidingen.
• Openbaar : Dit wordt gebruikt voor serviceklassen van API-eindpunten of hulpprogrammamethoden die worden gedeeld over verschillende delen van een applicatie.