En Java, les modificateurs d'accès sont des outils essentiels qui définissent comment les membres d'une classe comme les méthodes de variables et même la classe elle-même sont accessibles à partir d'autres parties de notre programme.

Il existe 4 types de modificateurs d'accès disponibles en Java : 

Modificateur d'accès privé

Le modificateur d'accès privé est spécifié à l'aide du mot-clé private. Les méthodes ou données membres déclarées comme privées ne sont accessibles que dans la classe dans laquelle elles sont déclarées.

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 

Explication: L’accès direct au nom n’est pas autorisé en dehors de la personne appliquant l’encapsulation.

Modificateur d'accès par défaut

Lorsqu'aucun modificateur d'accès n'est spécifié pour une méthode de classe ou un membre de données, il est dit qu'il a le modificateur d'accès par défaut. Cela signifie que seules les classes du même package peuvent y accéder.

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 

Explication: Les membres avec un accès par défaut ne sont pas accessibles à partir des classes d’un autre package.

Geeks.java : Classe par défaut dans le même package

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

GeeksNew.java : Classe par défaut d'un package différent (pour le contraste)

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

Explication:  Dans cet exemple, le programme affichera l'erreur de compilation lorsque nous essaierons d'accéder à une classe de modificateur par défaut à partir d'un autre package.

Modificateur d'accès protégé

Le modificateur d'accès protégé est spécifié à l'aide du mot-clé protégé. Les méthodes ou données membres déclarées comme protégées sont accessibles au sein du même package ou des sous-classes de différents packages.

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 

Explication: la vitesse est accessible via les méthodes de sous-classe et d'autres classes du même package, mais l'accès direct à partir d'un package différent (non-sous-classe) échouerait.

Modificateur d'accès public

Le modificateur d'accès public est spécifié à l'aide du mot-clé public. Les membres publics sont accessibles de partout dans le programme. Il n’y a aucune restriction quant à la portée des données publiques membres.

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 

Explication: add() est accessible globalement grâce au modificateur public.

Les classes ou interfaces de niveau supérieur ne peuvent pas être déclarées comme privées car privé signifie « uniquement visible dans la classe englobante ».

Tableau de comparaison des modificateurs d'accès en Java

Quand utiliser chaque modificateur d'accès dans des projets du monde réel

• Privé: L'idée devrait être d'utiliser un accès aussi restrictif que possible afin que le privé soit utilisé autant que possible.
• Défaut (Package-Private) : souvent utilisé dans les utilitaires ou les classes d'assistance au niveau du package.
• Protégé: Couramment utilisé dans les conceptions basées sur l'héritage comme les extensions de framework.
• Publique : Ceci est utilisé pour les classes de services de points de terminaison d'API ou les méthodes utilitaires partagées entre différentes parties d'une application.