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

Qui a le droit de manipuler votre code

Un modificateur d'accès est un mot-clé placé devant une classe, un champ, une méthode ou un constructeur, qui décide qui d'autre est autorisé à l'utiliser. C'est le fondement de l'encapsulation : vous cachez les rouages désordonnés d'une classe et n'exposez que les parties dont vous faites confiance à l'autre code pour les appeler.

Java possède quatre niveaux, du plus ouvert au plus verrouillé : public, protected, default (aucun mot-clé du tout) et private. Si vous les choisissez bien, une classe devient sûre à modifier plus tard, car rien à l'extérieur ne dépend de détails que vous n'avez jamais promis de conserver.

private : visible uniquement à l'intérieur de la classe

private est le niveau le plus strict. Un membre private ne peut être manipulé que par du code écrit à l'intérieur de la même classe - ni les sous-classes, ni les autres classes du même paquetage, personne. C'est là que la plupart de vos champs doivent se trouver.

public class Main {
    static class BankAccount {
        private double balance = 0;

        public void deposit(double amount) {
            if (amount > 0) {
                balance += amount;
            }
        }

        public double getBalance() {
            return balance;
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(100);
        account.deposit(-50); // ignoré par la vérification à l'intérieur de deposit
        System.out.println(account.getBalance());
    }
}

balance est private, donc la seule façon de le modifier passe par deposit, qui refuse les montants négatifs. Si balance était public, n'importe quel code pourrait écrire account.balance = -9999 et contourner entièrement la vérification. Cette protection est toute la raison d'être de la dissimulation du champ.

Essayez de décommenter account.balance = 500; dans main et vous obtiendrez une erreur de compilation : balance has private access in BankAccount.

public : visible partout

public est l'extrême opposé - n'importe qui, où que ce soit, peut utiliser le membre. Les noms de vos méthodes que l'autre code est censé appeler sont généralement public. La classe elle-même l'est aussi lorsqu'elle doit être atteignable depuis d'autres paquetages.

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

    public static void main(String[] args) {
        Greeter g = new Greeter();
        System.out.println(g.greet("Ada"));
    }
}

Le motif courant - parfois appelé l'API publique d'une classe - est le suivant : champs privés, méthodes publiques. Les champs détiennent l'état auquel personne d'autre ne devrait toucher ; les méthodes sont les portes contrôlées d'entrée et de sortie. getBalance et deposit ci-dessus en sont exactement l'illustration.

default (package-private) : aucun mot-clé du tout

Si vous n'écrivez aucun modificateur, vous obtenez l'accès default, aussi appelé package-private. Le membre est visible par toutes les classes du même paquetage et invisible pour tout ce qui se trouve en dehors. Il n'existe aucun mot-clé pour ce niveau - l'absence de mot-clé est le niveau.

class Invoice {       // aucun modificateur -> visible uniquement dans ce paquetage
    int amount;       // aucun modificateur -> champ package-private
}

Cela piège beaucoup de débutants : omettre public ne rend pas une chose private, cela la rend package-private. Un champ que vous vouliez garder secret reste entièrement lisible et modifiable par toute classe qui se trouve dans le même paquetage. Si vous voulez qu'il soit réellement caché, vous devez écrire private explicitement.

L'accès default est réellement utile pour les classes auxiliaires qui constituent un détail d'implémentation d'un paquetage - vous ne les exportez pas, mais les classes qui coopèrent au sein du paquetage peuvent toujours les utiliser librement.

protected : le paquetage plus les sous-classes

protected est d'un cran plus souple que default. Un membre protected est visible partout où default l'est (le même paquetage), et aussi par les sous-classes - même les sous-classes situées dans un paquetage différent. Il est conçu pour les choses que vous voulez partager avec les classes qui étendent la vôtre, mais pas avec le monde entier.

public class Main {
    static class Animal {
        protected String name;

        Animal(String name) {
            this.name = name;
        }

        protected String sound() {
            return "...";
        }
    }

    static class Dog extends Animal {
        Dog(String name) {
            super(name);
        }

        // La sous-classe peut lire le champ protected et appeler la méthode protected.
        public String describe() {
            return name + " says " + sound();
        }

        @Override
        protected String sound() {
            return "Woof";
        }
    }

    public static void main(String[] args) {
        System.out.println(new Dog("Rex").describe());
    }
}

Dog accède à name et à sound() parce qu'ils sont protected et que Dog est une sous-classe. Le code extérieur qui n'est pas une sous-classe et n'est pas dans le paquetage ne peut toujours pas y toucher. Recourez à protected lorsque vous concevez une classe destinée à être étendue ; sinon, préférez private.

Les quatre niveaux en un coup d'œil

Voici le tableau complet, du plus restrictif au plus ouvert :

Modificateur	Même classe	Même paquetage	Sous-classe (autre paquetage)	Partout
private	oui	non	non	non
default	oui	oui	non	non
protected	oui	oui	oui	non
public	oui	oui	oui	oui

Une règle empirique simple : commencez par private et ne desserrez que lorsque quelque chose a réellement besoin d'un accès plus large. Il est bien plus facile d'élargir l'accès plus tard que de le restreindre une fois que d'autres codes ont commencé à dépendre d'un membre.

Modificateurs sur les classes elles-mêmes

Les modificateurs d'accès s'appliquent aussi aux classes, pas seulement aux membres - mais une classe de premier niveau (non imbriquée dans une autre) ne peut être que public ou default. Vous ne pouvez pas écrire une classe de premier niveau private ou protected.

public class Order { ... }   // atteignable depuis n'importe quel paquetage
class LineItem { ... }       // default - seul ce paquetage peut la voir

Une classe public de premier niveau doit se trouver dans un fichier portant son nom (Order.java). Les classes imbriquées, en revanche, peuvent utiliser les quatre modificateurs - c'est pourquoi les exemples ci-dessus pouvaient marquer les classes internes comme private ou default. Un point subtil : une méthode public qui renvoie un type package-private n'est pas très utile aux appelants extérieurs, alors gardez votre surface publique cohérente.

Suite : les membres statiques

Jusqu'ici, chaque champ et chaque méthode appartient à une instance - vous créez un objet avec new puis vous appelez des méthodes sur lui. Mais parfois une valeur ou un comportement appartient à la classe dans son ensemble, partagé par toutes les instances, comme un compteur du nombre d'objets existants. C'est à cela que sert le mot-clé static, et c'est ce qui vient ensuite.