|
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 accessible
uniquement aux classes d'un package et à ses classes
filles
- private : un élément
private (privé) est accessible 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 accessible 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;
}
}
 
|
