Qu'est-ce que l'encapsulation ?

Imagine qu'une application bancaire stocke le solde de chaque compte dans une simple variable. N'importe quelle ligne du programme peut écrire account.balance = -500, et rien ne l'en empêche. Quand un solde négatif apparaît en production, il faut fouiller tout le code pour trouver chaque endroit qui l'a touché. L'encapsulation règle ce problème : le solde ne peut changer qu'à travers quelques méthodes, et ces méthodes font respecter les règles, par exemple qu'un retrait ne peut jamais dépasser le solde.

Comment fonctionne l'encapsulation

L'encapsulation combine deux idées :

1. Le regroupement. Les données (le solde) et le code qui agit dessus (dépôt, retrait) vivent dans la même classe.
2. Le masquage. Le reste du code ne voit que l'interface publique de la classe. Les données derrière elle sont internes, donc elles ne peuvent changer que de la façon dont la classe l'autorise.

La règle que protège la classe s'appelle un invariant : ici, « le solde n'est jamais négatif ». Comme chaque modification passe par les méthodes de la classe, l'invariant tient quoi que fasse le reste du programme.

class BankAccount:
    def __init__(self):
        self._balance = 0  # internal: change it only through the methods

    @property
    def balance(self):     # read-only from outside
        return self._balance

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("not enough money")
        self._balance -= amount

acct = BankAccount()
acct.deposit(100)
acct.withdraw(30)
print(acct.balance)
try:
    acct.withdraw(500)
except ValueError as err:
    print("refused:", err)

70
refused: not enough money

Le code extérieur peut lire acct.balance, mais la propriété n'a pas de setter, donc acct.balance = 1000 lève une AttributeError. Si le solde est un jour faux, il y a exactement deux méthodes à examiner.

L'encapsulation en Python

Python n'a pas de mot-clé private. Il s'appuie sur des conventions de nommage que tout programmeur Python connaît :

• name : public, fait partie de l'interface.
• _name : interne. Rien ne t'empêche de le lire, mais l'underscore initial signifie « ne dépends pas de ceci ».
• __name : Python le renomme à l'intérieur de la classe (name mangling), pour qu'une sous-classe ne puisse pas l'écraser par accident.
• @property : transforme une méthode en quelque chose qui se lit comme un attribut, pour que tu puisses ajouter des vérifications plus tard sans changer le code appelant.

class Counter:
    def __init__(self):
        self._count = 0      # one underscore: "internal, please don't touch"
        self.__secret = 42   # two underscores: the name gets mangled

c = Counter()
print(c._count)                   # still readable: it is only a convention
print(hasattr(c, "__secret"))     # the plain name does not exist
print(c._Counter__secret)         # Python renamed it to _Counter__secret

0
False
42

Le name mangling empêche les accidents, pas l'accès : le nom transformé fonctionne toujours. Python fait confiance aux programmeurs pour respecter l'underscore. En pratique, la plupart du code Python utilise un seul underscore plus @property, et réserve le double underscore aux classes destinées à être dérivées. Pour en savoir plus sur l'écriture de classes, consulte la documentation Python sur les classes.

L'encapsulation en Java, C++ et JavaScript

D'autres langages imposent le masquage. En Java, un attribut private ne peut être utilisé qu'à l'intérieur de sa propre classe :

public class BankAccount {
    private int balance;  // hidden from every other class

    public int getBalance() { return balance; }

    public void withdraw(int amount) {
        if (amount > balance) throw new IllegalArgumentException("not enough money");
        balance -= amount;
    }
}

Écrire account.balance = 1000; dans une autre classe ne compile pas : javac signale balance has private access in BankAccount.

En C++, les membres d'une class sont privés par défaut et ceux d'une struct publics. Les attributs privés # de JavaScript, ajoutés dans ES2022, ne peuvent pas du tout être lus depuis l'extérieur de la classe. La documentation couvre chacun : les modificateurs d'accès en Java, les spécificateurs d'accès en C++ et les champs privés en JavaScript.

Pourquoi l'encapsulation compte

• Les règles vivent à un seul endroit. La vérification « pas de retrait au-dessus du solde » est écrite une fois, dans withdraw, au lieu d'être répétée avant chaque retrait du programme.
• Tu peux modifier l'intérieur librement. Si tu décides de stocker l'argent en centimes entiers au lieu d'un float, seule la classe change. Le code qui appelle deposit(100) continue de fonctionner.
• Un débogage plus simple. Quand une valeur est fausse, les suspects sont les quelques méthodes autorisées à la modifier, pas chaque ligne du programme.
• Moins à apprendre et à tester. Une classe avec trois méthodes publiques peut être comprise et testée à travers ces trois méthodes.

L'encapsulation fonctionne aussi au-dessus du niveau des classes. Un module qui expose deux fonctions et garde dix fonctions utilitaires internes est encapsulé de la même façon, tout comme un système d'exploitation qui ne laisse les programmes ouvrir des fichiers qu'à travers des appels système.

On la confond souvent avec l'abstraction. L'abstraction décide de ce que l'interface propose ; l'encapsulation protège les données qui se trouvent derrière. La page sur l'abstraction contient une comparaison complète des deux. Avec le polymorphisme et l'héritage, elles forment les quatre piliers de la programmation orientée objet.

Erreurs fréquentes

• Un getter et un setter pour chaque attribut. Un setBalance qui accepte n'importe quel nombre ne protège rien. Propose les opérations dont l'objet a besoin (withdraw), pas un accès brut à chaque attribut.
• Renvoyer des objets internes. Une méthode qui renvoie self._items donne à l'appelant la vraie liste, qu'il peut désormais modifier. Renvoie plutôt une copie ou un tuple.
• Confondre privé et sécurité. Les modificateurs d'accès empêchent les erreurs, pas les attaques. Du code Java peut lire les attributs privés par réflexion, et du code Python peut lire _name directement. Les mots de passe et les clés ont besoin d'une vraie protection, comme le hachage et le chiffrement.

Pour aller plus loin

Lis ensuite la page sur l'abstraction, qui explique la différence entre les deux idées, puis celle sur le polymorphisme. Le cours Python construit des classes pas à pas, et le cours Java montre l'encapsulation imposée par le compilateur.