Encapsulation (programmation)

En programmation, l’encapsulation désigne le regroupement de données avec un ensemble de routines qui en permettent la lecture et la manipulation. Ce principe est souvent accompagné du masquage de ces données brutes afin de s’assurer que l’utilisateur ne contourne pas l’interface qui lui est destinée. L’ensemble se considère alors comme une boîte noire ayant un comportement et des propriétés spécifiés.

L’encapsulation est un pilier de la programmation orientée objet, où chaque classe définit des méthodes ou des propriétés pour interagir avec les données membres, mais ce principe peut se rencontrer dans d’autres styles de programmation (par exemple la programmation modulaire).

Motivations 
 L'encapsulation permet de modifier les structures de données internes sans modifier l’interface de celle-ci et donc sans pénaliser les utilisateurs. Cette situation arrive fréquemment lorsque l’on veut améliorer l’efficacité (rapidité de traitement) d’une classe ou d’un module, il faut souvent modifier les structures de données en conséquence.
L'encapsulation permet d’ajouter aisément des règles de validation et des contraintes d’intégrité, par exemple limiter le domaine des valeurs qu’une variable peut prendre (validité) ou vérifier que cette valeur n’entre pas en conflit avec les valeurs d’autres variables (intégrité).
L'encapsulation évite l’antipattern plat de spaghetti qui ne permet pas de déterminer le qui, le quoi et le comment d’une modification de données. En effet, l'application systématique de l'encapsulation impose un couplage faible et empêche donc le couplage fort, par espace commun ou par contenu, responsable du plat de spaghetti. 
Finalement, l'encapsulation permet d’offrir une interface orientée services et responsabilités, c’est-à-dire, d’offrir aux utilisateurs (programmeurs, abstractionnistes et architectes) de la classe ou du module une interface indiquant clairement quels services sont offerts et quelles sont les responsabilités de cette classe ou module.

Implémentation 
Les principes de l'encapsulation sont appliqués de manières très diverses suivant les langages. Mais on peut quand même trouver deux courants principaux.

Premièrement, une application relativement stricte des principes dans les langages objet purs (pour autant que ce terme ait un sens) comme dans SmallTalk ou Eiffel. Dans ce cadre les attributs ne sont souvent disponibles qu'en lecture en général dans le programme et en écriture aussi depuis l'intérieur de la classe d'objet. On trouve ensuite différents moyens pour adapter ce cadre à des classes amies ou à des catégories et des hiérarchies d'objets.

Deuxièmement, les langages tels que C++, Java ou Ruby et plus généralement tous les langages influencés par la syntaxe du C++ qui a proposé trois niveaux de visibilité :

 public : les attributs publics sont accessibles à tous ;
 protégé : les attributs protégés sont accessibles seulement à la classe elle-même et aux classes dérivées ;
 privé : les attributs privés sont accessibles seulement par la classe elle-même.

Ce type d'encapsulation propose en fait une autre approche de l'encapsulation qui ne fait pas la distinction entre la lecture et l'écriture d'un attribut. Dans ce cadre, on peut aussi utiliser des méthodes d'accès et de modifications définies dans l'un de ces niveaux de visibilité suivant l'effet que l'on souhaite obtenir. Souvent des méthodes des deux types sont définies en plus de l'attribut qui contient réellement la donnée. Enfin, des moyens autorisent d'autres classes et fonctions libres à librement accéder à tous les attributs d'une classe, comme c'est le cas avec les classes et fonctions amies en C++.

Notes et références 
 
 Pressman R. S., Software Engineering: A Practitioner's Approach, Third Edition. McGraw-Hill. Chapitre 10, 1992.

Voir aussi 

 Le principe de masquage de l'information.
 La métrique de cohésion.
 La métrique de couplage.
 La métrique d'indépendance fonctionnelle.

Architecture logicielle
Programmation orientée objet