Travailler directement avec les attributs des classes

Question

J'ai entendu dire que ce n'était pas une bonne idée de travailler directement avec les attributs de la classe, mais plutôt d'utiliser des setters et des getters. Quelqu'un peut-il me dire pourquoi ?

Answer 1

En fin de compte, Java ne respecte pas le principe de l'égalité de traitement entre les hommes et les femmes dans le domaine de la santé. Principe d'accès uniforme . En d'autres termes, le code client permettant de modifier la valeur d'un champ (par ex. obj.field = newValue ) est très différent du code permettant d'invoquer un setter (par ex. obj.setField(newValue) ).

Si vous commencez par un champ public et que vous décidez par la suite que vous avez vraiment besoin d'un membre privé (par exemple pour ajouter une validation ou pour modifier l'implémentation sous-jacente du membre), tout votre code client sera interrompu. Par conséquent, vous devez utiliser un setter plutôt qu'un champ public s'il y a un champ toute chance que vous aurez besoin des capacités supplémentaires offertes par les accesseurs. Le résultat final est un grand nombre de codes inutiles :

public class Person {
   private String _firstName;
   private String _lastName;

   public Person(String firstName, String lastName) {
      _firstName = firstName;
      _lastName = lastName;
   }

   public String getFirstName() {
      return _firstName;
   }

   public void setFirstName(String name) {
      _firstName = name;
   }

   public String getLastName() {
      return _lastName;
   }

   public void setLastName(String name) {
      _lastName = name;
   }
}

Dans les langues qui respectent l'UAP, telles que Scala il est assez courant d'utiliser des champs publics au lieu de getters/setters. La classe ci-dessus en Scala, par exemple, est écrite :

class Person(var firstName: String, var lastName: String)

// example client code:
val p = new Person("John", "Smith");
p.lastName = "Brown";

Si je décide que j'ai besoin d'être validé, je peux remplacer cela par :

class Person(firstName: String, lastName: String)
   private var _firstName = validate(firstName);
   private var _lastName = validate(lastName);

   // getters
   def firstName: String = _firstName
   def lastName: String = _lastName

   // setters
   def firstName_=(name: String): Unit = { 
      _firstName = validate(name); 
   }

   def lastName_=(name: String): Unit = { 
      _lastName = validate(name); 
   }

   // validation
   @throws(classOf[IllegalArgumentException])
   private def validate(name: String): String = { 
      // ... validation code ...
      name
   }
}

// and client code doesn't break!
val p = new Person("John", "Smith");
p.lastName = "Brown";