Visibilité des membres d'une classe

Un membre d'une classe désigne un attribut ou une méthode définie dans cette classe.

La visibilité des membres d'une classe définit les endroits d'où ils peuvent être utilisés. Dans cette section, nous allons voir deux sortes de visibilité: la visibilité publique et la visibilité privée.

Les membres privés d'une classe ne sont accessibles que par les méthodes de la classe:

• Les attributs privés d'une classe ne peuvent être utilisés que par les méthodes de cette classe.
• Les méthodes privées d'une classe ne peuvent être appelées que par les méthodes de cette classe.

Les membres publics d'une classe sont accessibles de l'extérieur de la classe:

• Les attributs publics d'une classe sont accessible (en lecture ou en écriture) depuis n'importe quelle partie du programme.
• Les méthodes publiques d'une classe peuvent être appelées depuis n'importe quelle partie du programme.

Une classe est encapsulée, si tous ses attributs sont privés.

Visibilité des membres en Pascal Objet

Pascal Objet offre cinq types de visibilité: Private, Strict Private, Protected, Public et Published. Si rien n'est précisé, c'est implicitement la visibilité Public qui est utilisée.

Je ne parlerais ici que de Strict Private et Public, qui correspondent aux visibilités privée et publique dont j'ai parlé précédemment.

Juste un mot sur Private. On pourrait croire d'après le nom qu'elle correspond à la visibilité privée. Mais non !

La visibilité Private de Pascal n'est pas réellement privée car elle autorise des accès depuis n'importe quel sous-programme ou méthode se trouvant dans la même unité.

Présentation de l'exemple

Pour illustrer le principe d'encapsulation, nous allons reprendre la classe Voiture en définissant la visibilité de ses membres de telle manière qu'elle soit encapsulée. Il s'agit donc d'une nouvelle version du projet Voiture1, que vous trouverez dans le dossier Exemple-ProgObjet2/Voiture2.

L'interface graphique de ce nouveau projet est exactement la même que celle du projet Voiture1:

De plus, les deux projets font exactement la même chose. Ils ne diffèrent que par le code.

Le projet comporte a présent deux unités:

• l'unité Voiture2.pas contient les procédures évènementielles associées à l'interface graphique.


• l'unités ClasseVoiture2.pas contient la définition de la classe Voiture.

L'unité Voiture2.pas utilise la classe Voiture définie dans l'unité ClasseVoiture2.pas.

Dans Voiture2.pas nous donnons deux utilisations de la classe:

• La première est une utilisation interdite, ne respectant pas la visibilité des membres de la classe. Elle provoquera une erreur de compilation.
• La deuxième respecte la visibilité des membres et ne provoque pas d'erreur de compilation.

L'une ou l'autre version peut être obtenue en mettant ou en enlevant les commentaires dans les procédures AfficherLaVoiture et TForm1.Bt_CreerClick.

Déclaration de la classe

Voici la nouvelle interface de la classe voiture.

Conformément au principe d'encapsulation, les attributs sont privés.

Dans cet exemple, toutes les méthodes sont publiques. Mais certaines d'entre elles auraient pu être privées sans enfreindre le principe d'encapsulation.

Pour simplifier les explications, nous avons enlever les méthodes Rouler, ChangerPneu et AfficherAttributs ainsi que le constructeur de la classe.

Les nouvelles méthodes, getCompteur, setCompteur, getImmat et setImmat sont les accesseurs de la classe. Ce sont eux qui vont nous permettre d'agir sur une instance de la classe depuis l'unité Voiture2.

Dans notre exemple, extrèmement simplifié, les accesseurs sont les seules méthodes de la classe. En général, ce n'est pas le cas.

Il y a deux types d'accesseurs:

• les accesseurs en lecture: ils permettent de lire la valeur d'un attribut. Ce sont des fonctions. Par convention leurs noms commencence par get.


• les accesseurs en écriture: ils permettent de modifier la valeur d'un attribut. Ce sont des procédures. Par convention leurs noms commencence par set.

Dans notre exemple, nous avons donc un accesseur en lecture et un accesseur en écriture pour chacun des attributs de la classe.

Voici le code de ces méthodes.

Dans les accesseurs en écriture, la valeur à affecter à l'attribut est passée en paramètre.

Dans le corps de l'accesseur, il peut être intéressant de n'affecter cette valeur que si elle vérifie certaines conditions. On peut de cette manière éviter des opérations inadéquates sur une instance de la classe.

Dans notre exemple, nous avons fait un contrôle de ce type dans l'accesseur setCompteur: lorsque la valeur passée en paramètre est supérieure à 10000, elle n'est pas affectée à l'attribut Compteur. Un message d'erreur est affichée.

Utilisation interdite de la classe

Voici une première version du module Voiture2.pas dans laquelle, on essaie d'accéder directement aux membres privés de la classe voiture.

Comme, on pouvait s'y attendre cette version provoque une erreur de compilation.

Par contre, on constate que si on rend les attributs Immat et Compteur publiques, le projet devient compilable et fonctionne très bien.

Utilisation autorisé de la classe

Pour qu'une classe encapsulée puisse être utilisée, il est nécessaire d'accéder à ses attributs de manière indirecte, via les accesseurs de la classe.

Voici, une deuxième version du module Voiture2.pas utilisant la classe Voiture encapsulée.

On constate que la compilation se passe bien et que le projet fonctionne correctement.