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.