Getters et Setters en Java

Bonjour ! Dans les leçons précédentes, tu as appris comment déclarer tes propres classes à part entière avec des champs et des méthodes. Cela représente de sérieux progrès, bien joué ! Mais maintenant, je dois t'avouer une triste vérité. Nous n'avons pas déclaré nos classes correctement ! Comment ça ? À première vue, il n'y a rien de mal à la classe suivante :

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

Et pourtant. Imagine que tu es à ton travail et que tu écris cette classe Cat pour représenter des chats. Et puis tu rentres chez toi. Pendant ton absence, un autre programmeur arrive au travail. Il crée sa propre classe Main, où il commence à utiliser la classe Cat que tu as écrite.

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";
       cat.age = -1000;
       cat.weight = 0;
   }
}

Peu importe pourquoi il l'a fait et comment ça s'est produit (peut-être que ce type a besoin de sommeil). Nous avons un problème plus important : en l'état, notre classe Cat autorise que des valeurs absolument folles soient affectées à ses champs. En conséquence, le programme a des objets avec un état non valide (comme ce chat qui est âgé de -1000 ans). Alors quelle erreur avons-nous faite lors de la déclaration de notre classe ? Nous avons exposé les données de notre classe. Les champs name, age et weight sont public. Ils sont accessibles partout dans le programme : crée simplement un objet Cat, et tout programmeur aura un accès direct à ses données par l'intermédiaire de l'opérateur point (.).

Cat cat = new Cat();
cat.name = "";

Ici, nous accédons directement au champ name et définissons sa valeur. Nous devons nous débrouiller pour protéger nos données de l'ingérence malvenue d'étrangers. Comment y parvenir ? Tout d'abord, nous devons marquer toutes les variables d'instance (les champs) avec le modificateur private. private est le modificateur d'accès le plus strict en Java. Une fois que tu as fait cela, les champs de la classe Cat ne seront plus accessibles en dehors de la classe.

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";//error! The Cat class's name field is private!
   }
}

Le compilateur voit cela et génère immédiatement une erreur. Maintenant, les champs sont plus ou moins protégés. Mais peut-être que nous avons un peu trop bien restreint l'accès : tu ne peux pas obtenir le poids d'un chat existant dans le programme, même si tu en as besoin. Cette solution n'est pas acceptable non plus. En l'état, notre classe est fondamentalement inutilisable. L'idéal serait de permettre une sorte d'accès limité :

• D'autres programmeurs devraient être en mesure de créer des objets Cat.
• Ils devraient être en mesure de lire les données à partir d'objets existants (par exemple, obtenir le nom ou l'âge d'un chat existant).
• Il devrait également être possible d'affecter des valeurs à ces champs. Mais seules des valeurs valides doivent être autorisées. Nos objets doivent être protégés contre les valeurs non valides (age = -1000, et ce genre de loufoqueries)

Ouah, ça nous fait beaucoup d'exigences ! En réalité, tout cela est facile à réaliser avec les méthodes spéciales appelées getters et setters. Ces noms proviennent de « get » (« une méthode pour obtenir la valeur d'un champ ») et « set » (« une méthode pour définir la valeur d'un champ »). Découvrons de quoi ces méthodes ont l'air dans notre classe Cat :

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       this.weight = weight;
   }
}

Comme tu peux le voir, elles se présentent assez simplement :) Leurs noms se composent souvent de « get »/« set » et du nom du champ concerné. Par exemple, la méthode getWeight() renvoie la valeur du champ weight de l'objet sur lequel elle est appelée. Voici à quoi cela ressemble dans un programme :

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       String smudgeName = smudge.getName();
       int smudgeAge = smudge.getAge();
       int smudgeWeight = smudge.getWeight();

       System.out.println("Cat's name: " + smudgeName);
       System.out.println("Cat's age: " + smudgeAge);
       System.out.println("Cat's weight: " + smudgeWeight);
   }
}

Sortie de la console :

Cat's name: Smudge
Cat's age: 5
Cat's weight: 4

Maintenant, une autre classe (Main) peut accéder aux champs de la classe Cat, mais seulement par le biais de getters. Remarque que les getters ont le modificateur d'accès public, ce qui signifie qu'ils sont disponibles depuis n'importe où dans le programme. Mais qu'en est-il de l'affectation de valeurs ? C'est à cela que les méthodes setter servent.

public void setName(String name) {
   this.name = name;
}

Comme tu peux le voir, elles sont également simples. Nous appelons une méthode setName() sur un objetCat, lui passons une chaîne comme argument, et la chaîne est affectée au champ name de l'objet.

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);

       System.out.println("Cat's original name: " + smudge.getName());
       smudge.setName("Mr. Smudge");
       System.out.println("Cat's new name: " + smudge.getName());
   }
}

Ici, nous utilisons à la fois des getters et des setters. Tout d'abord, nous utilisons un getter pour obtenir et afficher le nom d'origine du chat. Ensuite, nous utilisons un setter pour lui affecter un nouveau nom dans le champ name (« M. Smudge »). Ensuite, nous utilisons le getter une nouvelle fois pour obtenir le nom (pour vérifier s'il a vraiment changé). Sortie de la console :

Cat's original name: Smudge
Cat's new name: Mr. Smudge

Alors quelle est la différence par rapport à ce que nous faisions avant ? Nous pouvons toujours affecter des valeurs non valides aux champs même si nous avons des setters :

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       smudge.setAge(-1000);

       System.out.println("Smudge's age: " + smudge.getAge());
   }
}

Sortie de la console :

Smudge's age: -1000 years

La différence est qu'un setter est une méthode à part entière. Et contrairement à un champ, une méthode te permet d'écrire la logique de vérification nécessaire pour éviter d'avoir des valeurs inacceptables. Par exemple, tu peux facilement éviter l'affectation d'un nombre négatif au champ age :

public void setAge(int age) {
   if (age >= 0) {
       this.age = age;
   } else {
       System.out.println("Error! Age can't be negative!");
   }
}

Et maintenant notre code fonctionne correctement !

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       smudge.setAge(-1000);

       System.out.println("Smudge's age: " + smudge.getAge());
   }
}

Sortie de la console :

Error! Age can't be negative!
Smudge's age: 5 years

Dans notre setter, nous avons ajouté une vérification qui nous a protégés de la tentative de définition de données non valides. L'âge de Smudge n'a pas été modifié. Tu dois toujours créer des getters et des setters. Même s'il n'y a aucune restriction sur les valeurs que tes champs peuvent recevoir, ces méthodes d'assistance ne feront pas de mal. Imagine la situation suivante : toi et tes collègues écrivez un programme ensemble. Tu crées une classe Cat avec des champs public : Tous les programmeurs les utilisent comme ils veulent. Et puis un beau jour, tu réalises : « Zut, tôt ou tard quelqu'un pourrait accidentellement affecter un nombre négatif au poids ! Nous devons créer des setters et rendre tous les champs private ! » Tu fais exactement ça, et tout le code écrit par tes collègues cesse instantanément de fonctionner. Après tout, ils ont déjà écrit un tas de code qui accède aux champs de la classe Cat directement.

cat.name = "Behemoth";

Mais maintenant, les champs sont private et le compilateur génère un tas d'erreurs !

cat.name = "Behemoth";//error! The Cat class's name field is private!

Dans ce cas, il serait préférable de masquer les champs et de créer des getters et setters dès le départ. Tous tes collègues les auraient utilisés. Et si tu as réalisé un peu tard que tu as besoin de restreindre les valeurs d'un champ d'une manière ou d'une autre, tu aurais simplement pu écrire la vérification à l'intérieur du setter. Et comme ça tu n'aurais cassé le code de personne. Bien sûr, si tu veux limiter un champ à un accès en « lecture seule », tu peux te contenter de créer un getter uniquement. Seules les méthodes devraient être disponibles à l'extérieur (c'est-à-dire en dehors de ta classe). Les données doivent être cachées. Nous pourrions comparer cela à un téléphone mobile. Imagine qu'au lieu d'un téléphone mobile habituel dans son boîtier, tu as un téléphone avec un boîtier ouvert, avec toutes sortes de fils et de circuits qui dépassent. Le téléphone fonctionne : si tu fais un gros effort et que tu tritures les circuits, tu pourrais même réussir à passer un appel. Mais tu risques surtout de le casser. Au lieu de cela, le fabricant te donne une interface : l'utilisateur saisit simplement les bons chiffres, appuie sur le bouton vert d'appel, et l'appel commence. Tu ne te soucies pas de ce qui se passe à l'intérieur des circuits et des fils, ou de comment ils font leur travail. Dans cet exemple, le fabricant limite l'accès aux « entrailles » du téléphone (données) et expose seulement une interface (méthodes). Ainsi, l'utilisateur obtient ce qu'il veut (la capacité de passer un appel) sans risque de casser ce qui se trouve à l'intérieur.