Encapsulation de données

L'encapsulation des données est le concept le plus important à saisir lors de la programmation avec des objets. Dans la programmation orientée objet, l'encapsulation des données concerne:

• Combiner des données et comment elles sont manipulées en un seul endroit. Ceci est réalisé à travers l'état (les champs privés) et les comportements (les méthodes publiques) d'un objet.
• Autoriser uniquement l'accès et la modification de l'état d'un objet via des comportements. Les valeurs contenues dans l'état d'un objet peuvent alors être strictement contrôlées.
• Masquer les détails du fonctionnement de l'objet. La seule partie de l'objet accessible au monde extérieur est son comportement. Ce qui se passe à l'intérieur de ces comportements et la façon dont l'état est stocké ne sont pas visibles.

Application de l'encapsulation des données

Tout d'abord, nous devons concevoir nos objets pour qu'ils aient un état et des comportements. Nous créons des champs privés qui détiennent l'état et les méthodes publiques qui sont les comportements.

Par exemple, si nous concevons un objet personne, nous pouvons créer des champs privés pour stocker le prénom, le nom et l'adresse d'une personne. Les valeurs de ces trois champs se combinent pour créer l'état de l'objet. Nous pourrions également créer une méthode appelée displayPersonDetails pour afficher les valeurs du prénom, du nom et de l'adresse à l'écran.

Ensuite, nous devons faire des comportements qui accèdent et modifient l'état de l'objet. Cela peut être accompli de trois manières:

• Méthodes constructeurs. Une nouvelle instance d'un objet est créée en appelant une méthode constructeur. Des valeurs peuvent être transmises à une méthode constructeur pour définir l'état initial d'un objet. Il y a deux choses intéressantes à noter. Premièrement, Java n'insiste pas sur le fait que chaque objet a une méthode constructeur. Si aucune méthode n'existe, l'état de l'objet utilise les valeurs par défaut des champs privés. Deuxièmement, plusieurs méthodes constructeurs peuvent exister. Les méthodes diffèrent en fonction des valeurs qui leur sont transmises et de la manière dont elles définissent l'état initial de l'objet.
• Méthodes d'accesseur. Pour chaque champ privé, nous pouvons créer une méthode publique qui retournera sa valeur.
• Méthodes de mutation. Pour chaque champ privé, nous pouvons créer une méthode publique qui définira sa valeur. Si vous souhaitez qu'un champ privé soit en lecture seule, ne créez pas de méthode de mutation pour celui-ci.

Par exemple, nous pouvons concevoir l'objet personne pour avoir deux méthodes constructeurs. Le premier ne prend aucune valeur et définit simplement l'objet comme ayant un état par défaut (c'est-à-dire que le prénom, le nom et l'adresse seraient des chaînes vides). Le second définit les valeurs initiales du prénom et du nom de famille à partir des valeurs qui lui sont transmises. Nous pouvons également créer trois méthodes d'accesseur appelées getFirstName, getLastName et getAddress qui renvoient simplement les valeurs des champs privés correspondants. Créez un champ de mutation appelé setAddress qui définira la valeur du champ privé d'adresse.

Enfin, nous masquons les détails d'implémentation de notre objet. Tant que nous nous en tenons à garder les champs d'état privés et les comportements publics, il n'y a aucun moyen pour le monde extérieur de savoir comment l'objet fonctionne en interne.

Raisons de l'encapsulation des données

Les principales raisons d'employer l'encapsulation de données sont:

• Garder l'état d'un objet légal. En forçant un champ privé d'un objet à être modifié à l'aide d'une méthode publique, nous pouvons ajouter du code dans les méthodes mutateur ou constructeur pour nous assurer que la valeur est légale. Par exemple, imaginez que l'objet personne stocke également un nom d'utilisateur dans le cadre de son état. Le nom d'utilisateur est utilisé pour se connecter à l'application Java que nous construisons, mais il est limité à dix caractères. Ce que nous pouvons faire est d'ajouter du code dans la méthode de mutation du nom d'utilisateur qui s'assure que le nom d'utilisateur n'est pas défini sur une valeur supérieure à dix caractères.
• On peut changer l'implémentation d'un objet. Tant que nous conservons les mêmes méthodes publiques, nous pouvons changer le fonctionnement de l'objet sans casser le code qui l'utilise. L'objet est essentiellement une "boîte noire" du code qui l'appelle.
• Réutilisation d'objets. Nous pouvons utiliser les mêmes objets dans différentes applications parce que nous avons combiné les données et la façon dont elles sont manipulées en un seul endroit.
• L'indépendance de chaque objet. Si un objet est mal codé et provoque des erreurs, il est facile de le tester et de le corriger car le code est au même endroit. En fait, l'objet peut être testé indépendamment du reste de l'application. Le même principe peut être utilisé dans les grands projets où différents programmeurs peuvent être affectés à la création d'objets différents.