12.8 Méthodes d'encapsulation et d'accès (getters et setters) : encapsulation dans différents langages de programmation
L'encapsulation est l'un des quatre piliers fondamentaux de la programmation orientée objet (POO), avec l'héritage, l'abstraction et le polymorphisme. L'encapsulation est le principe qui vous permet de masquer les détails internes du fonctionnement d'un objet, en exposant uniquement les opérations sûres et nécessaires pour interagir avec cet objet. Cela se fait en contrôlant l'accès aux variables et méthodes internes d'une classe, en rendant certains membres privés et d'autres publics.
Les méthodes d'accès, connues sous le nom de getters et setters, sont le moyen le plus courant d'implémenter l'encapsulation dans de nombreux langages de programmation. Ce sont des méthodes publiques qui permettent de lire (getters) et d'écrire (setters) les propriétés privées d'une classe. Grâce à eux, il est possible de valider et de contrôler les valeurs attribuées aux variables, en maintenant l'intégrité et la cohérence de l'état interne de l'objet.
Encapsulation en Java
En Java, l'encapsulation est implémentée à l'aide de modificateurs d'accès : private, protected, public et default (non modificateur). Généralement, les variables d'instance sont définies comme privées, ce qui signifie qu'elles ne sont pas accessibles directement depuis l'extérieur de la classe. Pour permettre l'accès à ces variables, les méthodes getters et setters sont utilisées.
personne de classe publique {
nom de chaîne privé ;
âge int privé ;
chaîne publique getName() {
renvoyer le nom ;
}
public void setName (nom de la chaîne) {
this.name = nom ;
}
public int getAge() {
âge de retour;
}
public void setAge(int âge) {
si (âge > 0) {
this.age = âge;
}
}
}
Dans cet exemple, la méthode setAge inclut une validation pour garantir que l'âge n'est pas une valeur négative. Cela illustre comment les setters peuvent être utilisés pour appliquer des règles métier et maintenir l'intégrité des objets.
Encapsulation en C#
C# est un autre langage orienté objet qui prend en charge l'encapsulation de la même manière que Java. Cependant, C# propose une syntaxe plus simple pour déclarer des propriétés avec des getters et des setters automatiques, appelés propriétés auto-implémentées.
personne de classe publique {
chaîne publique Nom { get; ensemble; }
public int Âge {
obtenir { âge de retour ; }
set { âge = valeur > 0 ? valeur : âge; }
}
âge int privé ;
}
Dans cet exemple, la propriété Name est une propriété auto-implémentée qui crée automatiquement un champ privé sous-jacent. La propriété Age a une logique personnalisée dans le setter pour garantir que l'âge n'est pas négatif.
Encapsulation en Python
Python n'a pas de modificateurs d'accès explicites comme Java ou C#. Au lieu de cela, la convention consiste à utiliser un trait de soulignement (_) avant le nom d'un attribut pour indiquer qu'il doit être traité comme privé. Bien que cela n'empêche pas l'accès direct à l'attribut, cela indique aux autres développeurs que l'attribut est destiné à être utilisé en interne à la classe. Les méthodes getters et setters en Python sont souvent implémentées à l'aide des décorateurs @property, @attributo.setter et @atributo.deleter.
Personne de classe :
def __init__(soi, nom, âge) :
self._name = nom
self._age = âge
@propriété
nom def (soi) :
retourner soi._name
@nom.setter
nom def (soi, valeur) :
self._name = valeur
@propriété
âge par défaut (soi):
retourner soi._age
@idade.setter
def age (soi, valeur):
si valeur > 0 :
self._age = valeur
Les décorateurs @property et @name.setter vous permettent de définir des méthodes qui se comportent comme des attributs normaux, mais avec une logique supplémentaire pour la lecture et l'écriture.
Encapsulation JavaScript
JavaScript ne prenait traditionnellement pas en charge l'encapsulation de manière native, mais avec l'introduction des classes dans ECMAScript 2015 (ES6), cela a changé. Néanmoins, les champs privés sont un ajout plus récent au langage et sont désignés par un hachage (#) avant le nom du champ.
classe Personne {
#nom;
#âge;
constructeur (nom, âge) {
this.#name = nom;
this.#age = âge;
}
obtenir le nom() {
renvoie ceci.#name;
}
définir le nom (valeur) {
this.#name = valeur ;
}
obtenir l'âge() {
renvoie ceci.#age;
}
définir l'âge (valeur) {
si (valeur > 0) {
this.#age = valeur ;
}
}
}
Les méthodes get et set fonctionnent comme les getters et setters et permettent un accès contrôlé aux champs privés.
Conclusion
L'encapsulation est une pratique essentielle pour créer des logiciels robustes, sécurisés et faciles à entretenir. Bien que les langages de programmation puissent varier dans leurs approches spécifiques de mise en œuvre de l'encapsulation, le concept sous-jacent reste le même. Les méthodes d'accès getters et setters sont des outils puissants qui permettent aux développeurs de protéger l'état interne des objets et d'exposer une interface propre et compréhensible aux utilisateurs de ces classes. En maîtrisant l'encapsulation et en utilisant correctement les méthodes d'accès, les programmeurs peuvent garantir que leur code est plus fiable et maintenable à long terme.
