Î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.