Aller au contenu
Encyclopédie informatique Édition 2026

La programmation orientée objet

Partie 3 sur 5

Niveau de lecture :

6L’encapsulation

6.1Cacher pour protéger

L’encapsulation est un mécanisme qui consiste à rassembler les données et les méthodes au sein d’une même structure en cachant l’implémentation de l’objet, c’est-à-dire en empêchant d’accéder aux données autrement que par les services prévus. Elle permet de garantir l’intégrité des données contenues dans l’objet. C’est ce qu’on appelle aussi le masquage de l’information : l’utilisateur d’une classe n’a pas à savoir comment ses données sont structurées, il n’a pas à connaître son implémentation. En lui interdisant de modifier directement les attributs, et en l’obligeant à passer par les méthodes prévues pour cela, qui forment l’interface de la classe, on peut s’assurer de la cohérence des données : vérifier que le type des données fournies est conforme, ou qu’elles se trouvent dans l’intervalle attendu. Et l’on peut changer l’implémentation interne sans rien changer pour ceux qui utilisent la classe.

Un argument commercial s’ajoute : les classes étaient prévues pour être diffusées, parfois de façon payante, et réutilisées par d’autres programmeurs ; il est souhaitable que ceux-ci s’en servent comme le concepteur l’a prévu. L’encapsulation permet ainsi de restreindre l’accès à certains éléments, voire leur instanciation.

6.2Les niveaux de visibilité

L’encapsulation définit des niveaux de visibilité des éléments d’une classe, qui fixent les droits d’accès selon que l’on y accède depuis une méthode de la classe elle-même, d’une classe héritière ou de n’importe quelle autre classe. Il en existe trois principaux, désignés en C++, en Java, en C# ou en PHP par des étiquettes, ou mots-clés :

  • public (public) : les méthodes de toutes les classes peuvent accéder aux données ou aux méthodes ; c’est le plus bas niveau de protection ;
  • protégé (protected) : l’accès est réservé aux méthodes de la classe elle-même et à celles des classes dérivées ;
  • privé (private) : l’accès est limité aux méthodes de la classe elle-même ; c’est le niveau de protection le plus élevé.

Chaque langage a ses nuances. En C++, les membres d’une classe sont privés par défaut, et l’on écrit les étiquettes suivies de deux-points, public:, devant un groupe de membres. Java définit quatre niveaux : outre les trois précédents, un élément sans étiquette est accessible à toutes les classes du même paquetage (en anglais package, un regroupement de classes). On appelle parfois ce niveau « friendly », un nom non officiel emprunté au C++, et on le dit accessible aux classes du paquetage « et à ses classes filles » : c’est inexact, seules les classes du même paquetage y ont accès, les classes filles situées dans un autre paquetage en sont exclues ; en Java, c’est protected qui ouvre l’accès au paquetage et aux classes filles. Python, lui, n’a pas de mots-clés de visibilité : par convention, un nom commençant par un tiret bas, comme _vitesse, est réservé à l’usage interne, et deux tirets bas rendent l’accès malaisé depuis l’extérieur, sans l’interdire. JavaScript dispose, depuis 2022, d’attributs réellement privés, dont le nom commence par #.

6.3Accesseurs et mutateurs

Puisque les attributs privés ne peuvent pas être manipulés directement par les autres classes, le créateur de la classe doit prévoir des méthodes publiques spéciales pour y accéder :

  • les accesseurs (en anglais getters) permettent de récupérer la valeur d’un attribut. Un accesseur a pour type de retour celui de l’attribut, et n’a en général pas de paramètre ; une convention veut que son nom commence par get, comme getAge() ;
  • les mutateurs (en anglais setters) permettent de modifier la valeur d’un attribut. Un mutateur prend en paramètre la valeur à affecter, du type de l’attribut, et ne renvoie en général rien, son type de retour étant void ; son nom commence par convention par set, comme setAge().

L’intérêt principal de ce mécanisme est le contrôle de la validité des données : il est possible, et même conseillé, de tester la valeur reçue avant de l’affecter. On prend souvent l’exemple d’un mutateur qui refuse un âge supérieur à 200 ans, en notant avec humour que c’est avec de telles hypothèses qu’apparaissent les bogues, « ah, les progrès de la génétique ! ». Le même exemple cache un bogue plus immédiat, puisqu’il accepte un âge négatif (exercice 6). Une version plus robuste signale l’erreur par une exception plutôt que par un code de retour :

public void setAge(int nouvelAge) {
    if (nouvelAge < 0 || nouvelAge > 150) {
        throw new IllegalArgumentException("Âge invalide : " + nouvelAge);
    }
    this.age = nouvelAge;
}

Écrire systématiquement un accesseur et un mutateur pour chaque attribut revient pourtant souvent à rendre l’attribut public par un détour. Une bonne encapsulation expose plutôt des comportements : une classe Compte offre deposer() et retirer(), qui vérifient les règles métier, plutôt qu’un setSolde() qui permettrait d’écrire n’importe quel montant. C# et Python proposent par ailleurs des propriétés, qui s’utilisent comme des attributs mais appellent en coulisse des méthodes de contrôle.

Pour s’exercer

Exercice 2 : qui peut accéder ?

En Java, une classe Compte, dans le paquetage banque, possède les attributs private double solde, protected String titulaire, int numero (sans étiquette) et public String agence. Lesquels sont accessibles depuis : a) une autre classe du paquetage banque ; b) une sous-classe CompteEpargne située dans un autre paquetage ; c) une classe quelconque d’un autre paquetage ?

Voir la réponse

a) Dans le même paquetage : titulaire, numero et agence ; pas solde, privé. b) Dans une sous-classe d’un autre paquetage : titulaire, protégé, et agence, public ; pas numero, réservé au paquetage, contrairement à ce qu’on lit parfois, ni solde. c) Dans une classe quelconque d’un autre paquetage : seulement agence. Le solde ne se lit et ne se modifie que par les méthodes publiques de Compte.

7Constructeurs et destructeurs

7.1Le constructeur

Le constructeur est une méthode spéciale, appelée automatiquement lors de la création d’un objet ; en Java, c’est en réalité l’opérateur new qui fait appel à lui. C’est la première méthode exécutée, et son rôle est d’initialiser les attributs, ainsi que de réaliser toute action prévue par le concepteur au moment de l’instanciation. En C++ et en Java :

  • un constructeur porte le même nom que la classe dans laquelle il est défini ;
  • il n’a pas de type de retour, pas même void ;
  • il peut avoir des paramètres ;
  • sa définition n’est pas obligatoire : si la classe n’en possède pas, le compilateur fournit un constructeur par défaut, sans paramètre.

En PHP, le constructeur portait aussi le nom de la classe dans les anciennes versions ; il s’appelle __construct() depuis PHP 5. En Python, c’est la méthode __init__(), et en JavaScript la méthode constructor().

class Personne {
    private int age;
    private double taille;

    Personne(int age, double taille) {   // constructeur
        this.age = age;
        this.taille = taille;
    }
}

Personne p = new Personne(12, 1.62);

En C++, le constructeur est appelé différemment selon le mode de création : en statique, par le nom de la classe suivi du nom de l’objet et des paramètres entre parenthèses, Personne p(12, 1.62); ; en dynamique, par l’opérateur new, Personne *p = new Personne(12, 1.62);.

7.2Plusieurs façons de construire

Comme pour toute méthode, on peut surcharger les constructeurs, c’est-à-dire en définir plusieurs, qui diffèrent par le nombre ou le type de leurs paramètres. On peut ainsi initialiser un même type d’objet de plusieurs manières, et contrôler les valeurs reçues. Un exemple classique fournit une même information sous forme d’une lettre ou d’un nombre ; voici un exemple équivalent, une date de rendez-vous fournie soit sous forme de texte, soit sous forme de trois nombres :

class RendezVous {
    RendezVous(String texte) {                     // "2026-10-23"
        // découper le texte et vérifier qu'il s'agit d'une date valide
    }
    RendezVous(int jour, int mois, int annee) {
        if (mois < 1 || mois > 12) {
            throw new IllegalArgumentException("Mois invalide");
        }
        // ...
    }
}

Le compilateur choisit le constructeur à appeler d’après les paramètres fournis. Plusieurs langages permettent aussi des valeurs par défaut pour les paramètres, pour éviter de répéter une valeur qui est presque toujours la même : en C++, en Python ou en PHP, on écrit par exemple taille = 1.70 dans la liste des paramètres. Java ne le permet pas, et l’on y recourt à la surcharge.

7.3Le destructeur

Le destructeur est en quelque sorte au constructeur ce que la mort est à la vie, écrit-on plaisamment : c’est une méthode appelée automatiquement lors de la destruction d’un objet, qui lui permet d’« exaucer ses dernières volontés ». En C++, il porte le nom de la classe précédé d’un tilde, ~Personne(), n’a pas de type de retour, ne peut avoir aucun paramètre, et ne peut donc être ni surchargé, ni recevoir de valeur par défaut. Sa définition n’est pas obligatoire : un destructeur par défaut est appelé s’il n’en existe pas. Le destructeur d’un objet statique est appelé implicitement dès que le programme quitte la portée où l’objet existe ; celui d’un objet dynamique, par delete.

Les destructeurs sont beaucoup moins souvent nécessaires que les constructeurs. Ils deviennent indispensables lorsque l’objet possède des ressources à libérer : objets créés dynamiquement et chaînés par des pointeurs, fichiers ou connexions ouverts. Le C++ en a fait un principe de conception, appelé RAII (Resource Acquisition Is Initialization, « l’acquisition d’une ressource est une initialisation ») : une ressource est acquise dans le constructeur et libérée dans le destructeur, ce qui garantit sa libération. Dans les langages à ramasse-miettes, on ne sait pas quand un objet sera détruit : on libère donc les ressources explicitement, avec des constructions comme try avec ressources en Java ou with en Python.