Encapsulation :
L’
encapsulation est un mécanisme consistant à rassembler les données et les méthodes au sein d’une structure en cachant l’implémentation de l’objet, c’est-à-dire en empêchant l’accès aux données par un autre moyen que les services proposés.
L’encapsulation permet donc de garantir l’intégrité des données contenues dans l’objet.
Ainsi, si l’on veut protéger des informations contre une modification inattendue, on doit se référer au principe d’encapsulation.
L'encapsulation consiste donc à cacher l'état interne d'un objet et d'imposer de passer par des méthodes permettant un accès sécurisé à l'état de l'objet.
Pour mettre en oeuvre l'encapsulation, la première étape consiste à privatiser les attributs. Pour ce faire, un mot clé spécial vous est proposé :
private.
Ensuite, il faut fournir les méthodes d'accès sécurisées.
Voici quelques lignes directrices pour respecter le principe d’
encapsulation :
Faire un maximum de méthodes/champs privés possible, c’est le choix par défaut.
Utiliser au maximum les variables locales, et n’utilisez les champs que s’ils sont publics ou s’ils agissent en tant que variables globales à la classe (toujours privés).
Faire des accesseurs/mutateurs s’il y a la moindre restriction concernant un champ : lecture seule, risque d’instabilités, comportement spécifique…
Utiliser astucieusement la composition, l’héritage, les interfaces et les méthodes statiques.
Composition :C’est le fait d’avoir une instance de classe dans une autre, et ainsi permettre aux deux d’interagir ensemble.
Dans l’absolu, la composition devrait être le seul moyen de faire communiquer des objets entre eux.
Héritage :C’est le fait de baser la définition d’une classe (fille) sur une autre (mère), afin d’en récupérer les membres (champs et méthodes).
En réalité, le but ultime de l’héritage est de faire du
polymorphisme : un procédé qui permet d’offrir une même interface de programmation pour des types différents.
Ce type de polymorphisme est particulièrement efficace quand vous voulez regrouper plusieurs objets de types différents dans un même tableau (par exemple : pour les passer dans un foreach).
Le duo
héritage/polymorphisme va permettre de définir un type commun à tous ces objets afin de ne plus avoir à faire du cas par cas lors du traitement.
Interface :Il s’agit d’un ensemble de signatures de méthodes sans implémentation, et les classes liées à cette interface devront obligatoirement implémenter ces méthodes.
Bien sûr, les interfaces n’empêchent pas de coder n’importe comment, mais elles ont le mérite :
-De forcer les développeurs à respecter le principe d’encapsulation au maximum, en faisant apparaître uniquement les méthodes qui seront accessibles depuis l’extérieur.
-D’empêcher les développeurs d’utiliser les objets d’une manière imprévue.
-De donner une ligne directrice en indiquant explicitement les fonctionnalités à développer.
-De documenter le code, car les interfaces contiennent théoriquement toutes les règles métier.
-De normaliser le nom des API, car plusieurs classes très similaires peuvent implémenter la même interface (exemple : IEnumerable en C#).
-À séparer correctement les règles métier, car une seule classe peut implémenter plusieurs interfaces.
Méthodes statiques :Il s’agit de méthodes qui ne nécessitent pas d’instance de classe pour être utilisées. Ce ne sont ni plus ni moins que des fonctions.
Les méthodes statiques servent à plusieurs choses, mais principalement, elles permettent de créer des comportements génériques, utilisables partout dans le programme.
====================
Navigation :
<-- Liens du Wiki : <--<-- Accueil du WIKI : <-- <-- Rappels de Programmation <--====================
Documentation :
====================