Les accesseurs et modificateurs (alias setters et getters) sont utiles pour trois raisons principales:
- Ils restreignent l'accès aux variables.
- Par exemple, une variable est accessible, mais pas modifiée.
- Ils valident les paramètres.
- Ils peuvent provoquer certains effets secondaires.
Les universités, les cours en ligne, les didacticiels, les articles de blog et les exemples de code sur le Web soulignent tous l'importance des accesseurs et des modificateurs, ils se sentent presque comme un "must have" pour le code de nos jours. On peut donc les trouver même s'ils ne fournissent aucune valeur supplémentaire, comme le code ci-dessous.
public class Cat {
private int age;
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
}
Cela dit, il est très courant de trouver des modificateurs plus utiles, ceux qui valident réellement les paramètres et lèvent une exception ou retournent un booléen si une entrée non valide a été fournie, quelque chose comme ceci:
/**
* Sets the age for the current cat
* @param age an integer with the valid values between 0 and 25
* @return true if value has been assigned and false if the parameter is invalid
*/
public boolean setAge(int age) {
//Validate your parameters, valid age for a cat is between 0 and 25 years
if(age > 0 && age < 25) {
this.age = age;
return true;
}
return false;
}
Mais même alors, je ne vois presque jamais les modificateurs appelés depuis un constructeur, donc l'exemple le plus courant d'une classe simple avec laquelle je suis confronté est le suivant:
public class Cat {
private int age;
public Cat(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
/**
* Sets the age for the current cat
* @param age an integer with the valid values between 0 and 25
* @return true if value has been assigned and false if the parameter is invalid
*/
public boolean setAge(int age) {
//Validate your parameters, valid age for a cat is between 0 and 25 years
if(age > 0 && age < 25) {
this.age = age;
return true;
}
return false;
}
}
Mais on pourrait penser que cette deuxième approche est beaucoup plus sûre:
public class Cat {
private int age;
public Cat(int age) {
//Use the modifier instead of assigning the value directly.
setAge(age);
}
public int getAge() {
return this.age;
}
/**
* Sets the age for the current cat
* @param age an integer with the valid values between 0 and 25
* @return true if value has been assigned and false if the parameter is invalid
*/
public boolean setAge(int age) {
//Validate your parameters, valid age for a cat is between 0 and 25 years
if(age > 0 && age < 25) {
this.age = age;
return true;
}
return false;
}
}
Voyez-vous un schéma similaire dans votre expérience ou est-ce juste que je suis malchanceux? Et si vous le faites, alors qu'est-ce qui, selon vous, est à l'origine de cela? Y a-t-il un inconvénient évident à utiliser des modificateurs des constructeurs ou sont-ils simplement considérés comme plus sûrs? Est-ce autre chose?