Modificateurs d'accès Java : public, private, protected, default

Les modificateurs d'accès déterminent qui peut voir et utiliser une classe, un champ, une méthode ou un constructeur. Java propose quatre niveaux — public, protected, package-private (aucun mot-clé) et private — qui vont de "le monde entier" à "uniquement cette classe". Choisir le bon modificateur est la façon dont vous délimitez l'interface d'un objet de ses éléments internes.

Les quatre niveaux

Du plus permissif au plus restrictif :

Modificateur	Visible depuis
`public`	N'importe où
`protected`	Même package, ou toute sous-classe (même dans un autre package)
(aucun mot-clé)	Même package uniquement — package-private
`private`	Même classe uniquement

C'est tout. Pas de "friend", pas de "module-internal" à ce niveau ; la visibilité de module est une fonctionnalité distincte du Java Platform Module System dont vous n'avez généralement pas besoin.

`public`

Un membre public fait partie de l'API publiée de la classe — visible par tout code qui peut voir la classe elle-même :

public class Greeter {
  public String greet(String name) {
    return "Hello, " + name;
  }
}

new Greeter().greet("world");    // anyone can call this

Utilisez public pour ce que vous souhaitez que d'autres codes — même d'autres projets — puissent appeler. Le coût est que dès qu'un membre est public, vous vous y engagez ; modifier la signature rompt chaque appelant.

`private`

private restreint un membre à sa classe déclarante. Rien en dehors ne peut y toucher — pas même une sous-classe :

public class Account {
  private int balance;     // only Account can read/write

  public void deposit(int amount) {
    if (amount <= 0) throw new IllegalArgumentException();
    balance += amount;      // ok — same class
  }
}

Account a = new Account();
a.balance = -1;             // ERROR — balance is private

C'est l'outil privilégié pour les champs. Cacher l'état derrière private est ce qui donne tout son sens à la validation dans deposit. Le chapitre sur l'encapsulation détaille ce modèle.

Package-private (aucun mot-clé)

Omettez entièrement le modificateur et le membre est visible par tout ce qui se trouve dans le même package — mais rien en dehors :

// in package com.shop
class CartHelper {           // no public — package-private
  static int sum(int[] prices) { ... }
}

Les autres classes de com.shop peuvent appeler CartHelper.sum(...) ; le code dans com.app ne peut même pas voir que la classe existe. Utilisez ceci pour les assistants internes que le package doit partager mais qui ne font pas partie de l'API externe du projet.

Une erreur fréquente : omettre le modificateur par oubli, puis être surpris que la classe soit utilisable depuis main (également dans le même package lors de l'apprentissage) mais pas depuis un test dans un package différent.

`protected`

protected correspond à package-private plus les sous-classes. Le code du même package peut utiliser le membre, et toute sous-classe — même dans un package différent — peut l'utiliser :

public class Shape {
  protected double area;       // subclasses can read/write
}

public class Circle extends Shape {
  Circle(double r) {
    this.area = Math.PI * r * r;   // ok — subclass access
  }
}

C'est le modificateur à utiliser lorsque vous souhaitez que les sous-classes puissent s'intégrer aux mécanismes du parent, sans que le code client général puisse y toucher. En pratique, protected apparaît bien moins souvent que public ou private ; beaucoup de concepteurs préfèrent des champs private avec des méthodes d'accès protected pour le même effet avec plus de contrôle.

Où les modificateurs s'appliquent

Vous pouvez placer un modificateur sur :

Une classe elle-même (public class Foo). Les classes de niveau supérieur ne peuvent être que public ou package-private. Les classes internes peuvent être l'une des quatre.
Un champ (private int count).
Une méthode (public int get() {...}).
Un constructeur (private Singleton() {...} — voir le patron singleton).

Vous ne pouvez pas mettre de modificateur d'accès sur une variable locale ou un paramètre de méthode. Ceux-ci sont délimités uniquement par l'endroit où ils sont déclarés.

La règle "une classe publique par fichier"

Un fichier .java peut déclarer plusieurs classes de niveau supérieur, mais au plus l'une d'elles peut être public, et son nom doit correspondre au nom du fichier :

// file: Order.java
public class Order { ... }          // ok — matches filename
class OrderHelper { ... }           // ok — package-private
public class Customer { ... }       // ERROR — second public class

La plupart des projets gardent une classe par fichier de toute façon, mais des assistants package-private à côté d'une classe publique sont parfois utiles.

Choisir le bon modificateur

Une règle empirique qui passe à l'échelle :

Par défaut, utilisez private pour les champs et les méthodes auxiliaires.
public pour les méthodes que vous voulez réellement appeler de l'extérieur.
Package-private pour ce qui doit être partagé à l'intérieur d'un package mais pas exposé au-delà.
protected uniquement lorsque vous souhaitez spécifiquement un accès aux sous-classes.

Il est facile d'élargir l'accès plus tard (private → public) ; il est pénible de le restreindre sans rompre les appelants. Commencez avec le niveau le plus restrictif.

Les modificateurs ne changent pas le comportement

Un modificateur d'accès est une vérification à la compilation. À l'exécution, deux champs int égaux se comportent de manière identique qu'ils aient été déclarés public ou private. Le modificateur existe uniquement pour empêcher d'autres codes de compiler en référence au membre — pour faire respecter une limite que vous déclarez.

Un exemple concret

java— editable, runs on the server

public class AccessModifiers {
  // private — visible only to BankAccount
  // public  — anyone can call deposit/withdraw/balance
  static class BankAccount {
    private int balance;            // hidden state
    private final String owner;

public BankAccount(String owner, int opening) {
      this.owner   = owner;
      this.balance = opening;
    }

public void deposit(int amount) {
      requirePositive(amount);
      balance += amount;
    }

public boolean withdraw(int amount) {
      requirePositive(amount);
      if (amount > balance) return false;
      balance -= amount;
      return true;
    }

public int    balance() { return balance; }
    public String owner()   { return owner; }

// private helper — internal validation, not part of the API
    private static void requirePositive(int amount) {
      if (amount <= 0) {
        throw new IllegalArgumentException("amount must be > 0");
      }
    }
  }

public static void main(String[] args) {
    BankAccount a = new BankAccount("Alice", 100);

a.deposit(50);
    System.out.println(a.owner() + " has " + a.balance());

boolean ok = a.withdraw(200);
    System.out.println("big withdrawal allowed? " + ok);

a.withdraw(75);
    System.out.println(a.owner() + " has " + a.balance());

try {
      a.deposit(-1);
    } catch (IllegalArgumentException e) {
      System.out.println("rejected: " + e.getMessage());
    }

// a.balance = 999_999;        // would not compile — balance is private
  }
}

La suite

public, protected, private sont des modificateurs d'accès. Java possède une autre famille — les modificateurs non liés à l'accès comme static, final, abstract, synchronized — qui contrôlent le comportement plutôt que la visibilité. Le chapitre suivant, les modificateurs non liés à l'accès, en propose un tour d'horizon.

Entraînement

Pratique

Un champ est déclaré sans aucun modificateur d'accès — juste int count;. Qui peut le lire ?

Tout code dans le même package que la classe déclaranteTout code n'importe où — aucun modificateur signifie publicUniquement la classe déclaranteLa classe déclarante et toute sous-classe, quel que soit le package