Le concept d'accessibilité (généralement
appelé encapsulation) définit la possibilité qu'a le concepteur d'une classe
de restreindre l'accès à certaines données, ou plus généralement
à certains éléments (méthodes, classes, ...).
En effet, les classes sont prévues pour être diffusées (parfois de façon payante)
afin de pouvoir être réutilisées par certains programmeurs. Or il est généralement
souhaitable que les utilisateurs de la classe se servent de celle-ci de la manière de laquelle le concepteur a prévu
qu'elle le soit. Ainsi, il est possible de restreindre l'accès à (ou bien l'instanciation de) certains éléments en leur
associant une étiquette.
l'encapsulation consiste donc à définir
des étiquettes pour les données membres et les méthodes afin de préciser
si celles-ci sont accessibles à partir d'autres classes ou non...
De cette manière, des données membres portant l'étiquette private
ne peuvent pas être manipulées directement par les méthodes des autres classes.
Ainsi, pour pouvoir manipuler ces données membres, le créateur de la classe (vous en l'occurrence)
doit prévoir des méthodes spéciales portant l'étiquette public, permettant
de manipuler ces données.
- Les fonctions membres permettant d'accéder aux données membres sont appelées accesseurs,
parfois getter (appelation d'origine anglophone)
- Les fonctions membres permettant de modifier les données membres sont appelées mutateurs,
parfois setter (appelation d'origine anglophone)
On appelle généralement "interface" l'ensemble des méthodes permettant à l'utilisateur
de manipuler une classe.
Java définit quatre niveaux d'accès pour les variables d'instances
(données membres) et les méthodes:
- public : un élément public est accessible
de partout et sans aucune restriction. Certaines classes (comme la classe principale main) doivent
obligatoirement être déclarées publiques (pour pouvoir exécuter l'application...)
- protected : un élément protected (protégé) est accesible
uniquement aux classes d'un package et à ses classes filles
- private : un élément private (privé) est accesible
uniquement au sein de la classe dans laquelle il est déclaré. Ces éléments
ne peuvent être manipulés qu'à l'aide de méthode spécifiques
appelés accesseur et mutateur
- "friendly" : un élément est friendly par défaut (cette appellation n'est pas officielle et est empruntée
au langage C++) est accesible
uniquement aux classes d'un package et à ses classes filles.
Un accesseur est une méthode permettant de récupérer le contenu d'une
donnée membre protégée. Un accesseur, pour accomplir sa fonction:
- doit avoir comme type de retour le type de la variable à renvoyer
- ne doit pas nécessairement posséder d'arguments
Une convention de nommage veut que l'on fasse commencer de façon préferrentielle
le nom de l'accesseur par le préfixe Get, afin de faire ressortir sa fonction première.
La syntaxe d'un accesseur réduit à sa plus simple expression ressemble donc à ceci:
public class MaClasse{
public static void main(String[] argv){
new MaSecondeClasse();
}
}
class MaSecondeClasse{
private TypeDeMaVariable MaVariable;
public TypeDeMaVariable GetMaVariable(){
return MaVariable;
}
}
Sur l'exemple précédent, l'accesseur minimal de la donnée membre age
pourrait être le suivant:
class Toto{
private int age;
public int GetAge(){
return age;
}
}
Un mutateur est une méthode permettant de modifier le contenu d'une
donnée membre protégée. Un mutateur, pour accomplir sa fonction:
- doit avoir comme paramètre la valeur à assigner à la donnée membre. Le paramètre
doit donc être du type de la donnée membre
- ne doit pas nécessairement renvoyer de valeur (il possède dans sa plus simple expression le type void)
Une convention de nommage veut que l'on fasse commencer de façon préferrentielle
le nom du mutateur par le préfixe Set.
La syntaxe d'un mutateur réduit à sa plus simple expression ressemble donc à ceci:
class MaClasse{
private TypeDeMaVariable MaVariable;
public void SetMaVariable(TypeDeMaVariable MaValeur){
MaVariable = MaValeur;
}
}
Sur l'exemple précédent, le mutateur minimal de la donnée membre age
pourrait être le suivant:
class Toto{
private int _age;
public void SetAge(int age){
_age = age;
}
}
L'intérêt principal d'un tel mécanisme est le contrôle de la validité
des données membres qu'il procure. En effet, il est possible (et même conseillé) de tester la
valeur que l'on assigne à une donnée membre, c'est-à-dire que l'on effectue
un test de validité de la valeur de l'argument avant de l'affecter à la donnée membre.
Le mutateur ci-dessus peut par exemple vérifier si l'âge de Toto est correct
(on considérera pour cela que Toto ne peut pas vivre plus de 200 ans...c'est avec des hypothèses
telles que celle-ci que peuvent apparaître des bogues...ah les progrès de la génétique!).
class Toto{
private int _age;
public int SetAge(int age){
if (age < 200) {
_age = age;
return 1;
}
else return 0;
}
}
|