Encapsulation (programmation informatique)

L'encapsulation, définie comme « pouvant servir à masquer les membres de données et les fonctions membres », consiste généralement à dissimuler la représentation interne d'un objet en dehors de sa définition. En règle générale, seules les méthodes propres à l'objet peuvent accéder directement à ses champs ou les manipuler. Masquer le fonctionnement interne de l'objet protège son intégrité en empêchant les utilisateurs de modifier ses données internes pour les rendre invalides ou incohérentes. L'encapsulation présente l'avantage supposé de réduire la complexité du système et, par conséquent, d'accroître sa 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 les méthodes d'objet, tandis que la plupart des autres (par exemple, C++ , C# , Delphi ou Java ) offrent au programmeur un certain contrôle sur les informations masquées, généralement via des mots-clés comme `private` publicet `private` private. La norme ISO C++ qualifie `private` protected, `private` privateet public`private` de « spécificateurs d'accès » et précise qu'ils ne « masquent aucune information ». Le masquage d'informations est réalisé en fournissant une version compilée du code source, 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 des mécanismes comme la modification de noms ( Python ) ou l'utilisation de mots-clés spéciaux comme frienden C++. Les systèmes qui offrent une sécurité basée sur les capacités au niveau de l'objet (conformément au modèle objet-capacité ) constituent une exception et garantissent une encapsulation forte.

Exemples

Restriction des champs de données

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

Voici 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 { privée décimale _solde_compte = 500.00m ;public decimal CheckBalance () { return _accountBalance ; } }static void Main () { Account myAccount = new (); decimal myBalance = myAccount . CheckBalance ();/* Cette méthode Main 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" */ } }

Voici un exemple en Java :

public class Employee { private BigDecimal salary = new BigDecimal ( 50000.00 ); public BigDecimal getSalary () { return this . salary ; }public static void main ( ) { Employee e = new Employee (); 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 » #pragma oncetypedef struct Entity Entity ; // Structure opaque avec des membres cachés// Fonctions API qui opèrent sur des objets 'Entity' Entity * openEntity ( int id ); int processEntity ( Entity * e ); void closeEntity ( Entity * e );

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

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

Déformation de noms

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