Encapsulation (programmation informatique)

Dans les systèmes logiciels, l'encapsulation fait référence au regroupement de données avec les mécanismes ou méthodes qui opèrent sur ces données. Elle peut également faire référence à la limitation de l'accès direct à certaines de ces données, comme les composants d'un objet. Essentiellement, l'encapsulation empêche le code externe de s'intéresser au fonctionnement interne d'un objet.

L'encapsulation permet aux développeurs de présenter une interface cohérente et indépendante de son implémentation interne. Par exemple, l'encapsulation peut être utilisée pour masquer les valeurs ou l'état d'un objet de données structurées à l'intérieur d'une classe . Cela empêche les clients d'accéder directement à ces informations d'une manière qui pourrait exposer des détails d'implémentation cachés ou violer l'invariance d'état maintenue par les méthodes.

L'encapsulation encourage également les programmeurs à placer tout le code concerné par un certain ensemble de données dans la même classe, ce qui l'organise pour une compréhension facile par d'autres programmeurs. L'encapsulation est une technique qui encourage le découplage .

Tous les systèmes de programmation orientée objet (OOP) prennent en charge l'encapsulation, mais l'encapsulation n'est pas propre à la programmation orientée objet. Les implémentations de types de données abstraits , de modules et de bibliothèques offrent également l'encapsulation. La similitude a été expliquée par les théoriciens du langage de programmation en termes de types existentiels .

Dans les langages de programmation orientés objet et d'autres domaines connexes, l'encapsulation fait référence à l'une des deux notions liées mais distinctes, et parfois à leur combinaison :

• Un mécanisme de langage permettant de restreindre l'accès direct à certains composants de l' objet .
• Une construction de langage qui facilite le regroupement de données avec les méthodes (ou autres fonctions) opérant sur ces données.

Certains chercheurs et universitaires en langage de programmation utilisent la première signification seule ou en combinaison avec la seconde comme caractéristique distinctive de la programmation orientée objet , tandis que certains langages de programmation qui fournissent des fermetures lexicales considèrent l'encapsulation comme une caractéristique du langage orthogonale à l'orientation objet.

La deuxième définition reflète le fait que dans de nombreux langages orientés objet et d'autres domaines connexes, les composants ne sont pas masqués automatiquement et que cela peut être contourné. Ainsi, le masquage d'informations est défini comme une notion distincte par ceux qui préfèrent la deuxième définition.

Les fonctionnalités d'encapsulation sont prises en charge à l'aide de classes dans la plupart des langages orientés objet, bien que d'autres alternatives existent également.

Les auteurs de Design Patterns discutent longuement de la tension entre héritage et encapsulation et affirment que, d'après leur expérience, les concepteurs abusent de l'héritage. Ils affirment que l'héritage brise souvent l'encapsulation, étant donné que l'héritage expose une sous-classe aux détails de l'implémentation de son parent. Comme le décrit le problème du yo-yo , l'abus d'héritage et donc d'encapsulation peut devenir trop compliqué et difficile à déboguer.

Selon la définition selon laquelle l'encapsulation « peut être utilisée pour masquer des membres de données et des fonctions membres », la représentation interne d'un objet est généralement masquée en dehors de la définition de l'objet. En règle générale, seules les méthodes propres à l'objet peuvent inspecter ou manipuler directement ses champs. Le masquage des éléments internes de l'objet protège son intégrité en empêchant les utilisateurs de définir les données internes du composant dans un état non valide ou incohérent. L'un des avantages supposés de l'encapsulation est qu'elle peut réduire la complexité du système, et donc augmenter la robustesse , en permettant au développeur de limiter les interdépendances entre les composants logiciels.

Certains langages comme Smalltalk et Ruby n'autorisent l'accès que via des méthodes d'objet, mais la plupart des autres (par exemple, C++ , C# , Delphi ou Java ) offrent au programmeur un certain contrôle sur ce qui est caché, généralement via des mots-clés comme publicet private. La norme ISO C++ fait référence à protected, privateet publiccomme des « spécificateurs d'accès » et indique qu'ils ne « cachent aucune information ». Le masquage des informations est réalisé en fournissant une version compilée du code source qui est interfacée via un fichier d'en-tête.

Il existe presque toujours un moyen de contourner cette protection, généralement via l'API de réflexion (Ruby, Java, C#, etc.), parfois par un mécanisme comme la modification des noms ( Python ) ou l'utilisation de mots-clés spéciaux comme frienden C++. Les systèmes qui fournissent une sécurité basée sur les capacités au niveau des objets (en adhérant au modèle de capacité des objets ) sont une exception et garantissent une encapsulation solide.

Des langages comme C++ , C# , Java , PHP , Swift et Delphi offrent des moyens de restreindre l'accès aux champs de données.

Vous trouverez ci-dessous un exemple en C# qui montre comment l'accès à un champ de données peut être restreint grâce à l'utilisation d'un privatemot-clé :

classe Programme { classe publique Compte { classe privée décimale _accountBalance = 500.00 m ;
décimal public CheckBalance () { return _accountBalance ; } }
static void Main () { Compte monCompte = nouveau Compte (); décimal monSolde = monCompte . CheckBalance ();
/* Cette méthode principale peut vérifier le solde via la 
 méthode publique * "CheckBalance" fournie par la classe "Account" 
 * mais elle ne peut pas manipuler la valeur de "accountBalance" */ 
} }

Ci-dessous un exemple en Java :

classe publique Employé { private BigDecimal salary = new BigDecimal ( 50000.00 ); public BigDecimal getSalary () { renvoie ceci . salaire ; }
public static void main () { Employé e = nouvel employé (); BigDecimal sal = e . getSalary (); } }

L'encapsulation est également possible dans les langages non orientés objet. En C , par exemple, une structure peut être déclarée dans l'API publique via le fichier d'en-tête d'un ensemble de fonctions qui opèrent sur un élément de données contenant des membres de données qui ne sont pas accessibles aux clients de l'API avec le externmot-clé.

// Fichier d'en-tête "api.h"
struct Entity ; // Structure opaque avec membres cachés
// Fonctions API qui opèrent sur les objets 'Entity' 
extern struct Entity * open_entity ( int id ); extern int process_entity ( struct Entity * info ); extern void close_entity ( struct Entity * info ); // Les mots-clés extern sont ici redondants, mais ne font pas de mal. // extern définit des fonctions qui peuvent être appelées en dehors du fichier actuel, le comportement par défaut même sans le mot-clé

Les clients appellent les fonctions API pour allouer, exploiter et désallouer des objets d'un type de données opaque . Le contenu de ce type est connu et accessible uniquement à l'implémentation des fonctions API ; les clients ne peuvent pas accéder directement à son contenu. Le code source de ces fonctions définit le contenu réel de la structure :

// Fichier d'implémentation "api.c"
#include "api.h"
struct Entity { int ent_id ; // Numéro d'identification char ent_name [ 20 ]; // Nom ... et autres membres ... };
// Implémentations de fonctions API 
struct Entity * open_entity ( int id ) { ... }
int processus_entité ( struct Entité * info ) { ... }
void close_entity ( struct Entité * info ) { ... }

Vous trouverez ci-dessous un exemple de Python qui ne prend pas en charge les restrictions d'accès aux variables. Cependant, la convention veut qu'une variable dont le nom est préfixé par un trait de soulignement soit considérée comme privée.

classe 
Voiture : 
def 
__init__ ( self ) 
-> 
None : 
self . _maxspeed 
= 
200
def 
drive ( self ) 
-> 
None : 
print ( f "La vitesse maximale est { self . _maxspeed } . " )
redcar 
= 
Car () 
redcar . drive () 
# Ceci affichera « La vitesse maximale est de 200. »
redcar . _maxspeed 
= 
10 
redcar . drive () 
# Ceci affichera « La vitesse maximale est de 10. »