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.
En Gambas 3, l'
encapsulation est un concept de programmation orientée objet (POO) qui consiste à cacher les détails internes d'une classe et à protéger l'accès direct à ses données. Cela permet de contrôler comment les données sont manipulées et d'éviter des modifications inappropriées.
Principes de l'encapsulation en Gambas 3 :
1.
Visibilité des membres :
- Les propriétés et méthodes d'une classe peuvent être définies comme :
-
Public : Accessibles depuis n'importe où.
-
Private : Accessibles uniquement à l'intérieur de la classe elle-même.
-
Protected : Accessibles à l'intérieur de la classe et de ses classes dérivées (héritage).
2.
Utilisation des accesseurs (getters) et mutateurs (setters) :
- Pour contrôler l'accès aux propriétés privées, on utilise des méthodes spécifiques :
-
Get : Pour lire la valeur d'une propriété.
-
Set : Pour modifier la valeur d'une propriété.
Exemple en Gambas 3 :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| ' Déclaration d'une classe
CLASS Personne
' Propriété privée
PRIVATE Nom AS STRING
' Accesseur (getter) pour la propriété Nom
PUBLIC Property Get Nom() AS STRING
RETURN ME.Nom
END
' Mutateur (setter) pour la propriété Nom
PUBLIC Property Set Nom(Value AS STRING)
IF Value <> "" THEN
ME.Nom = Value
ELSE
ERROR "Le nom ne peut pas être vide"
ENDIF
END
END
|
Utilisation de la classe :
1
2
3
4
5
6
7
8
9
10
| PUBLIC SUB Main()
DIM p AS NEW Personne
' Utilisation du setter pour définir le nom
p.Nom = "Jean"
' Utilisation du getter pour obtenir le nom
PRINT p.Nom
END
|
Avantages de l'encapsulation :
-
Contrôle des données : Empêche les modifications directes et inappropriées.
-
Maintenabilité : Facilite la modification interne de la classe sans affecter le code qui l'utilise.
-
Sécurité : Protège les données sensibles.
En résumé, l'encapsulation en Gambas 3 permet de structurer et de sécuriser le code en limitant l'accès direct aux données internes d'une classe.
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 :
====================