Classes et objets en Java

Une classe définit un type : les données que ses objets mémorisent et les opérations qu’ils proposent. Un objet, aussi appelé instance, est une valeur de ce type créée pendant l’exécution d’un programme. Écrire une définition de classe ne crée pas d’objet.

État et comportement

Le nom, l’espèce et l’âge d’un animal de compagnie constituent son état. Ces valeurs actuelles sont contenues dans des variables d’instance, aussi appelées champs. Une opération comme fêter un anniversaire est un comportement, écrit sous forme de méthode. La méthode d’anniversaire va avec l’âge qu’elle modifie, ce qui permet de garder la règle à un seul endroit.

Imagine une classe comme un plan de construction. Beaucoup de maisons peuvent suivre un même plan, mais chacune possède son propre contenu. De même, deux animaux peuvent suivre la même définition et avoir des âges différents. Tu écris les noms des champs une seule fois ; chaque objet reçoit ses propres valeurs.

Lis une petite classe

public class Pet {
    private String name;
    private String species;
    private int age;

    public Pet(String name, String species, int age) {
        this.name = name;
        this.species = species;
        this.age = age;
    }

    public void celebrateBirthday() {
        this.age++;
    }
}

Lis ce code de l’extérieur vers l’intérieur. public class Pet introduit le type et les accolades extérieures contiennent sa définition. Les trois premières déclarations décrivent l’état. Le bloc nommé Pet est un constructeur : il donne ses premières valeurs à un nouvel objet. celebrateBirthday est une méthode : elle augmente l’âge de l’objet courant. Les mots private et public contrôlent l’accès ; les exemples suivants les utilisent pour protéger l’état.

Les paramètres du constructeur sont des valeurs fournies lors de la création d’un objet. Dans this.age = age;, le côté gauche désigne le champ de l’objet et le côté droit le paramètre fourni. Le constructeur stocke cette donnée pour que l’objet puisse la mémoriser après la fin de sa construction.

Utilise une classe

Tu as déjà utilisé des classes de bibliothèque. Scanner décrit des objets qui lisent des données en entrée, ArrayList décrit des listes et un objet String propose des opérations comme length(). Une classe que tu écris suit le même principe : elle met un type utile à la disposition du reste de ton programme.

Sans Pet, un programme pourrait transmettre séparément un nom, une espèce et un âge à de nombreuses méthodes. Il devrait maintenir correctement chaque groupe de valeurs. Un objet Pet réunit les valeurs liées en une seule entité. Les méthodes de cet objet savent quel âge elles doivent utiliser.

Organise et nomme le code

Pour les fichiers source ordinaires, une classe publique nommée Pet est enregistrée dans Pet.java, en respectant les majuscules. Une classe Main distincte peut contenir la méthode main du programme, créer des animaux et appeler leurs méthodes. Pet n’a pas besoin de sa propre méthode main. Les classes d’un même paquetage sans nom peuvent s’utiliser entre elles sans importation ; les exemples simples placent ces classes dans un même dossier.

Utilise des noms en UpperCamelCase pour les classes, comme LibraryBook. Utilise lowerCamelCase pour les champs et les méthodes : pageCount nomme une donnée ; giveBack() nomme une action. Ces conventions aident le lecteur à reconnaître chaque élément, même si le compilateur autorise bien d’autres noms.

Créer un objet et déclarer une variable sont deux opérations différentes. Une variable te donne un nom par lequel accéder à un objet ; new crée l’objet auquel ce nom fera référence.

Lis une instruction de création d’objet

Pet luna = new Pet("Luna", "cat", 3);

Pet est le type de la variable et luna est son nom. new Pet(...) crée un nouvel objet et appelle un constructeur correspondant avec trois arguments. Le constructeur stocke le nom, l’espèce et l’âge. La référence obtenue est affectée à luna.

Une référence indique à Java quel objet utiliser. Il est utile de représenter une variable par un nom accompagné d’une flèche vers un objet. La variable n’est pas une deuxième copie de tous les champs de l’objet.

Appelle une méthode sur un objet précis

Le point dans luna.celebrateBirthday() relie une référence à une méthode à exécuter sur son objet. Une méthode qui renvoie une valeur peut la fournir à une autre expression :

luna.celebrateBirthday();
int years = luna.getAge();
System.out.println(years); // 4

Ici, getAge() est une méthode publique qui renvoie l’âge de l’animal. L’appel lié à l’anniversaire modifie l’état ; l’accesseur lit cet état. Pet.celebrateBirthday() échoue parce que cette méthode d’instance a besoin d’un animal précis. Le nom de la classe seul ne dit pas de quel anniversaire il s’agit.

Objets distincts et références partagées

Pet max = new Pet("Max", "dog", 5);
luna.celebrateBirthday();
System.out.println(luna.getAge()); // 5
System.out.println(max.getAge());  // 5

Luna avait déjà 4 ans, donc l’anniversaire suivant la fait passer à 5 ans. Max reste à 5 ans. Des âges égaux ne font pas d’eux un même objet : les deux expressions new ont créé des animaux distincts.

Considère maintenant une affectation sans new :

Pet other = luna;
other.celebrateBirthday();
System.out.println(luna.getAge()); // 6

L’affectation copie la référence vers Luna. Les deux noms donnent accès au même animal : une modification effectuée par other est donc visible par luna. Pour créer un deuxième animal, appelle new à nouveau.

Respecte les paramètres du constructeur

Les arguments doivent correspondre au nombre, à l’ordre et aux types des paramètres d’un constructeur déclaré. Si le seul constructeur disponible prend (String, String, int), new Pet() ne se compile pas. Java ne devine pas les valeurs manquantes. En revanche, inverser les deux chaînes se compile quand même : new Pet("cat", "Luna", 3) fournit les bons types mais pas les bonnes significations. Lis les noms des paramètres pour vérifier leur ordre.

Ces deux tentatives inachevées échouent pour des raisons différentes :

Pet a;                         // declaration only
// System.out.println(a.getAge()); // a has no assigned value
// Pet b = Pet("Bo", "cat", 2);    // missing new

Une valeur doit être affectée à une variable locale avant son utilisation. Sans new, Java cherche une méthode nommée Pet, pas une expression de création d’objet. Une fois l’objet créé, l’afficher peut montrer un texte comme Pet@8bcc55f tant que tu ne fournis pas une méthode toString() lisible ; cette sortie ne signifie pas que la construction a échoué.

Un objet a besoin d’un champ pour chaque valeur qu’il doit mémoriser entre deux appels de méthode. Choisis ces valeurs avant d’écrire les méthodes : elles constituent l’état durable de l’objet.

Déclare des champs de types adaptés

Un champ se trouve entre les accolades de la classe, mais en dehors de tout constructeur et de toute méthode. Une déclaration comporte nécessairement un type et un nom ; elle peut aussi comporter un modificateur d’accès et un initialiseur.

private String title;
private int pageCount;
private boolean lentOut = false;

String convient au texte, int au dénombrement par un entier et boolean à une condition dont la réponse est oui ou non. Les champs peuvent aussi utiliser des types définis par des classes comme ArrayList<String>. Ces exemples utilisent private ; omettre le modificateur donne un accès de paquetage, pas un accès privé.

Chaque objet reçoit une copie distincte de chaque champ d’instance. Deux objets Rectangle ont chacun un champ width et un champ height, même si les déclarations n’apparaissent qu’une fois dans la classe.

Les valeurs par défaut ne sont pas toujours des valeurs initiales utilisables

Une valeur par défaut est affectée à un champ lorsque l’espace de stockage de l’objet est créé. Elle peut ne pas convenir à l’usage de l’objet. Un champ de type liste dont la valeur est null n’est pas une liste vide : tu dois encore créer la liste avant d’y ajouter un élément.

Les variables locales ne reçoivent pas de telle valeur par défaut. Dans une méthode, int total; suivi de System.out.println(total); ne se compile pas parce qu’aucune valeur n’a été affectée à total. Distingue bien la règle des champs de celle des variables locales.

Décide ce qui doit durer

Un champ reste associé à son objet. Un paramètre est disponible pendant son appel et une variable locale est disponible dans son bloc pendant l’exécution de cet appel. Si un compteur doit conserver son compte d’un appel à l’autre, le compte doit être placé dans un champ. Un sous-total temporaire utilisé pour un calcul peut être local.

Stocke les données ; calcule les valeurs dérivées

public class Rectangle {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return this.width * this.height;
    }
}

Les dimensions sont en centimètres, donc area() renvoie une aire en centimètres carrés. Stocker l’aire dans un champ distinct créerait une valeur supplémentaire à mettre à jour chaque fois que l’une des dimensions change. La calculer à partir des dimensions garantit la cohérence du résultat.

Utilise un champ d’instance final pour une valeur affectée une seule fois, comme private final String title;. Donne-lui une valeur dans sa déclaration ou dans chaque constructeur. final empêche toute réaffectation. static a un sens différent : il crée un champ de classe partagé. Ajouter static au nom d’un animal ferait partager une seule variable de nom à plusieurs animaux.

Un constructeur initialise un objet lorsque new le crée. Son nom doit correspondre à celui de la classe et il n’a pas de type de retour. Même void transformerait la déclaration en méthode.

Transfère les données dans l’état

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

Un constructeur accepte généralement des données sous forme de paramètres et les stocke dans des champs. Ici, chaque paramètre porte le même nom que son champ. Le nom seul age désigne le paramètre ; this.age désigne le champ de l’objet en cours de création. L’affectation lit la valeur fournie à droite et l’écrit dans le champ à gauche.

Pour new Pet("Luna", "cat", 3), les champs du nouvel objet reçoivent d’abord les valeurs par défaut : null, null et 0. Le constructeur reçoit ensuite les trois arguments et remplace ces valeurs. Une fois la construction terminée, new produit la référence que l’appelant stocke.

Deux bogues qui se compilent

public Pet(String name, String species, int age) {
    name = name;
    this.species = species;
    this.age = age;
}

Les deux occurrences de name désignent le paramètre : la première ligne affecte donc au paramètre sa propre valeur. Le nom de l’objet reste à null. Le code est valide, d’où l’importance de vérifier les valeurs du nouvel objet.

Une déclaration dans le constructeur provoque un problème similaire :

String nick = initialNick;

Si un champ nommé nick existe déjà, cette ligne crée une variable locale de même nom. La variable locale disparaît à la fin de la construction. Écris this.nick = initialNick; pour stocker la donnée dans le champ ; ne répète pas le type.

Sache quand un constructeur sans argument existe

Si une classe ne déclare aucun constructeur, Java fournit un constructeur par défaut sans paramètre. Pour une classe simple, ses champs conservent leurs valeurs initiales déclarées ou leurs valeurs par défaut. Dès que tu déclares un constructeur, Java cesse de fournir ce constructeur par défaut.

Une classe qui possède seulement Pet(String name, String species, int age) ne peut donc pas être instanciée avec new Pet(). Ajoute un constructeur explicite sans argument uniquement lorsqu’il existe un état initial utile pour celui-ci. Fais aussi attention à public void Pet(...) : c’est une méthode, elle ne fournit donc pas du tout le constructeur souhaité.

Définis aussi les valeurs initiales internes

Tous les champs n’ont pas besoin de provenir d’un argument. Un nouveau livre peut toujours commencer avec this.lentOut = false;. Une classe qui possède une liste peut l’initialiser ainsi, après importation de ArrayList :

private ArrayList<String> tracks;

public Playlist() {
    this.tracks = new ArrayList<>();
}

La liste vide est prête pour add. Laisser tracks à null provoque ensuite l’échec de tracks.add(...) avec une NullPointerException.

Un initialiseur de champ s’exécute avant le corps du constructeur. Si private int score = 10; est suivi de this.score = 5; dans le constructeur, le score de l’objet terminé est 5. Teste les valeurs après la construction, pas seulement les valeurs écrites à côté des déclarations de champs. Les constructeurs doivent aussi appliquer les mêmes règles de validation que les modifications ultérieures, afin que l’état initial soit valide.

Une classe peut proposer plusieurs façons utiles de créer un objet. La surcharge de constructeurs consiste à déclarer des constructeurs dont les listes de paramètres sont différentes.

Distingue les constructeurs par leurs paramètres

Java distingue les constructeurs par le nombre, les types et l’ordre de leurs paramètres. Les noms des paramètres ne permettent pas de les distinguer. Box(String label) et Box(String name) décrivent la même liste de paramètres : ils ne peuvent donc pas être tous deux déclarés dans une même classe.

Un animal peut être créé avec un âge ou comme nouveau-né :

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

public Pet(String name, String species) {
    this(name, species, 0);
}

new Pet("Pip", "rabbit") sélectionne le constructeur à deux paramètres. Ce constructeur fournit 0 pour l’âge manquant et appelle le constructeur à trois paramètres. L’état du nouvel objet contient finalement "Pip", "rabbit" et 0.

Chaîne l’initialisation sur le même objet

Dans un constructeur, this(...) appelle un autre constructeur de la même classe. Le constructeur le plus court choisit des valeurs par défaut ; le constructeur le plus complet effectue l’initialisation commune. Les vérifications placées dans cette initialisation s’appliquent aux deux façons de construire l’objet.

Compare deux lignes qui se ressemblent :

La deuxième ligne ne remplit pas les champs de l’objet courant. Si son résultat n’est jamais stocké, cet animal supplémentaire est abandonné. Les champs de l’animal courant peuvent encore valoir null.

Suis une chaîne avant de suivre le reste du code

Une horloge peut proposer minuit comme valeur par défaut :

public Clock() {
    this(0, 0);
}

public Clock(int hours, int minutes) {
    this.hours = hours;
    this.minutes = minutes;
}

Pour new Clock(), entre dans le constructeur sans argument, suis this(0, 0) et affecte les deux champs dans le constructeur à deux arguments. L’exécution revient ensuite au constructeur sans argument. Cela crée une seule horloge, pas deux. Un appel à new Clock(9, 5) démarre directement dans le constructeur le plus complet.

Garde une chaîne valide et claire

Un constructeur peut contenir au maximum un appel this(...). La chaîne doit finir par atteindre une initialisation qui ne rappelle pas un constructeur de la chaîne : deux constructeurs qui délèguent l’un à l’autre provoquent une erreur de compilation due à un appel récursif de constructeur.

Placer this(...) en premier est un style clair qui fonctionne dans toutes les versions de Java. Dans Java 24 et les versions antérieures sans fonctionnalités en avant-première, l’appel doit être en premier. Java 25 autorise des instructions avant cet appel, par exemple pour calculer ou vérifier des arguments. Ces instructions ne peuvent ni lire les champs d’instance de l’objet courant ni appeler ses méthodes d’instance ; les affectations aux champs déclarés dans la classe sans initialiseur dans leur déclaration sont autorisées.

Propose des surcharges parce que les appelants disposent de différentes données utiles. Une horloge réglée à minuit a un sens ; un livre sans titre n’en a pas forcément. L’existence d’un constructeur complet ne crée automatiquement aucune surcharge plus courte.

Une méthode d’instance s’exécute pour un objet précis. Déclare-la sans static et utilise les champs de cet objet avec des noms comme this.width. Décide de ce dont l’appelant a besoin : une modification de l’état, un résultat renvoyé ou les deux.

Renvoie les résultats des calculs ; rends explicites les modifications de l’état

Pour un rectangle dont les dimensions sont stockées en centimètres :

public double area() {
    return this.width * this.height;
}

public double perimeter() {
    return 2 * (this.width + this.height);
}

public void scale(double factor) {
    this.width = this.width * factor;
    this.height = this.height * factor;
}

Un rectangle de côtés 3,0 et 4,0 a une aire de 12,0 centimètres carrés et un périmètre de 14,0 centimètres. scale(2) fait passer les côtés à 6,0 et 8,0. Les appels suivants renvoient une aire de 48,0 et un périmètre de 28,0. Chaque méthode lit les champs actuels : aucune aire stockée n’a donc besoin d’être mise à jour.

area() renvoie un nombre qui peut être stocké ou utilisé dans un calcul. Si elle ne faisait qu’afficher le nombre et avait le type de retour void, l’appelant ne pourrait pas écrire double twice = r.area() * 2;. Laisse l’affichage à l’appelant lorsque le rôle d’une méthode est de calculer une valeur.

Mets à jour les champs liés dans l’ordre

La méthode advance() d’une horloge doit gérer le passage à l’heure et au jour suivants :

public void advance() {
    this.minutes++;
    if (this.minutes == 60) {
        this.minutes = 0;
        this.hours++;
        if (this.hours == 24) {
            this.hours = 0;
        }
    }
}

À 23 h 58, le premier appel atteint 23 h 59 et saute les deux blocs de remise à zéro. L’appel suivant atteint brièvement la minute 60, la remet à 0, fait passer l’heure à 24, puis la remet à 0. L’état final est 00 h 00. Un appel de plus donne 00 h 01.

Suis les objets séparément

Écris une ligne après chaque instruction et une colonne pour les champs de chaque objet. Ne modifie que l’objet désigné par le receveur de l’appel. Pour des animaux âgés de 2 et 7 ans, deux anniversaires pour le premier et setAge(1) pour le second donnent finalement les âges 4 et 1. N’exécute pas le corps d’une méthode pour toutes les instances simplement parce qu’elles partagent une classe.

Une déclaration locale peut masquer le champ que tu voulais mettre à jour. public void reset() { int count = 0; } ne crée qu’une variable temporaire. this.count = 0; remet à zéro le compte durable.

Réutilise les méthodes et complète les chemins de retour

Dans une méthode d’instance, area() et this.area() appellent la méthode de calcul de l’aire du même objet. Une méthode de description peut réutiliser ce calcul au lieu de copier son expression. Une méthode peut aussi modifier l’état et renvoyer une indication de réussite, comme lend() lorsqu’elle marque un livre comme emprunté et renvoie true.

Une méthode dont le type de retour est différent de void ne peut pas simplement atteindre sa fin sans renvoyer une valeur compatible. Si get() ne renvoie une valeur que dans if (count > 0), que se passe-t-il lorsque le compte vaut 0 ? Ajoute le chemin de retour nécessaire ou lève une exception pour une valeur que la méthode rejette. Un chemin qui lève une exception ne rend pas la main à l’appelant et n’a pas besoin de valeur de retour.

Demande-toi à qui appartient une valeur ou une opération avant de décider d’utiliser static. L’âge d’un animal appartient à cet animal. Le nombre de tous les animaux créés appartient à la classe entière.

L’objet courant est this

Dans un constructeur ou une méthode d’instance, this désigne l’objet en cours de construction ou celui qui reçoit l’appel. Dans this.age++, il indique l’objet dont l’âge change. Dans this.name = name, il distingue le champ d’un paramètre de même nom. this(...) est la forme utilisée pour chaîner les constructeurs.

Une méthode statique n’a pas d’objet courant : this ne peut donc pas y être utilisé. Elle peut toutefois créer un objet ou recevoir une référence et l’utiliser pour appeler des méthodes d’instance.

Champs partagés et champs propres aux objets

public class Counter {
    private int count;
    private static int created = 0;

    public Counter() {
        this.count = 0;
        created++;
    }

    public void increment() {
        this.count++;
    }

    public int getCount() {
        return this.count;
    }

    public static int getCreated() {
        return created;
    }
}

Après deux appels à new Counter(), il y a deux champs count distincts, initialement égaux à 0, et un champ created égal à 2. Incrémenter le premier compteur fait passer son compte à 1 ; celui du second reste à 0. Counter.getCreated() renvoie toujours 2, car aucun nouvel objet n’a été construit.

Utilise un objet depuis main

public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    System.out.println(c.getCount());
}

La méthode main classique est statique. Un appel à increment() seul à cet endroit n’aurait pas d’objet cible et ne se compilerait pas. La variable c fournit cette cible. Rendre count statique pour faire disparaître l’erreur changerait la conception : tous les compteurs partageraient alors un seul compte.

Java 25 prend aussi en charge des formes de main sous forme de méthode d’instance, mais l’en-tête statique classique reste valide. Ces exemples l’utilisent systématiquement.

Choisis les méthodes et les constantes avec soin

Une opération qui a besoin des champs d’un objet devrait être une méthode d’instance. Une opération qui dépend uniquement de ses paramètres peut être statique, comme une méthode auxiliaire qui convertit un nombre total de minutes en heures. Les appels statiques utilisent normalement le nom de la classe : Math.sqrt(16) ou Counter.getCreated().

Une valeur fixe partagée est généralement déclarée comme une constante :

public static final int MAX_CELSIUS = 30;

public la rend accessible aux appelants, static donne à la classe un champ partagé unique et final empêche sa réaffectation. Par convention, UPPER_SNAKE_CASE indique une constante. C’est une exception courante à la règle qui rend les champs privés. N’utilise pas static pour les noms, les dimensions ou tout autre élément d’état ordinaire qui doit différer d’un objet à l’autre.

L’encapsulation rassemble l’état d’un objet et le code qui le contrôle. Les champs sont généralement privés, tandis que les appelants utilisent des opérations publiques. Cela masque les détails du stockage et donne à la classe un endroit où faire appliquer ses règles.

Choisis un niveau d’accès

Un paquetage regroupe des classes. Les exemples simples placent des classes ordinaires ensemble sans déclaration package, dans un seul paquetage sans nom. L’accès de paquetage résulte de l’omission du modificateur ; il n’existe pas de mot-clé d’accès package à ajouter à un champ.

Commence par l’accès utile le plus restrictif. Rends les champs privés, les constructeurs et les opérations nécessaires aux autres classes publics, et les méthodes auxiliaires internes privées. Les constantes publiques sont une exception courante pour les champs.

Confie à la classe le contrôle des modifications

Si Pet déclare private int age;, une classe Main distincte ne peut pas effectuer l’affectation luna.age = -5;. Le compilateur rejette cet accès. Un appel comme luna.setAge(-5) peut être autorisé, car la méthode publique appartient à Pet et peut décider de stocker ou non l’argument.

Un champ public permettrait à tout appelant de contourner cette méthode. Lorsque toutes les modifications passent par le code de la classe, les vérifications peuvent être regroupées à un seul endroit. L’accès privé seul ne valide pas un âge ; les méthodes doivent aussi effectuer les vérifications.

Garde l’interface publique stable

Supposons qu’une horloge stocke initialement les champs distincts hours et minutes. Les appelants utilisent getHours() et getMinutes(). Tu remplaces ensuite les champs par une seule valeur minutesSinceMidnight :

public int getHours() {
    return this.minutesSinceMidnight / 60;
}

public int getMinutes() {
    return this.minutesSinceMidnight % 60;
}

Avec 615 minutes stockées, la division renvoie 10 et le reste vaut 15. L’horloge indique 10 h 15 par les mêmes méthodes. Le code des appelants n’a pas besoin d’être réécrit, car il dépendait des opérations publiques, pas de la façon dont l’état était stocké. Cette liberté de modifier les éléments internes est le masquage de l’information.

L’accès dépend des classes, pas des objets individuels

Le code dans Pet peut lire un champ privé d’un autre objet Pet. L’autorisation d’accès vient du fait que le code se trouve dans la classe. Une autre classe de premier niveau n’obtient pas cette autorisation en possédant une référence vers un animal ou en se trouvant dans le même dossier.

Pour les déclarations ordinaires de classes de premier niveau, les choix d’accès sont public ou aucun modificateur. Une déclaration private class Pet au premier niveau est interdite. Une classe publique de premier niveau va dans le fichier source correspondant, et un fichier source ordinaire contient au maximum une classe publique de premier niveau.

Les champs privés constituent une frontière dans la conception du programme. Ils empêchent le reste du code ordinaire de dépendre directement des champs internes, mais ne permettent pas de garder une valeur secrète pour une personne qui peut examiner le programme. Utilise-les pour contrôler l’interface de ta classe et protéger son état.

Une classe peut permettre aux appelants de lire ou de modifier certaines parties de son état par l’intermédiaire de méthodes. Décide des opérations que la classe devrait proposer avant de créer des méthodes d’accès pour chaque champ.

Renvoie des valeurs avec des accesseurs

Un accesseur, aussi appelé méthode d’accès, renvoie des informations sans modifier l’objet. Un accesseur courant lit un champ :

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

Le type de retour correspond à l’information fournie. Un accesseur qui affiche une valeur et renvoie void ne peut pas fournir de valeur à une expression comme pet.getAge() + 1. L’appelant devrait recevoir la valeur et décider comment l’utiliser.

Modifie certaines valeurs avec des mutateurs

Un mutateur, aussi appelé méthode de modification, reçoit une nouvelle valeur et met à jour l’état :

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

this.name est le champ. name est le paramètre. Écrire name = name; se compile mais ne modifie aucun champ. Il n’y a pas de valeur de retour ici, car le rôle de ce mutateur est d’effectuer une modification.

Pour un animal âgé de 3 ans :

luna.setName("Lulu");
System.out.println(luna.getName() + " is " + luna.getAge());
// Lulu is 3

L’appelant ne touche jamais directement à un champ. Le mutateur modifie le nom et les accesseurs renvoient les valeurs actuelles que l’appelant peut combiner.

Respecte les noms attendus par les autres codes Java

Mets en majuscule la première lettre du nom du champ après get, set ou le préfixe booléen habituel is. Un nom comme getname() peut se compiler, mais il ne suit pas la convention attendue par les outils et les autres programmeurs.

N’expose que les opérations utiles

Le titre d’un livre peut avoir un accesseur et aucun mutateur, car les appelants devraient pouvoir le lire sans le remplacer. Un champ privé final peut garantir qu’il ne reçoit une valeur qu’une fois. Un compteur interne peut n’avoir besoin ni d’accesseur ni de mutateur si seule la classe l’utilise.

Un mutateur sans vérification peut accepter la même valeur dommageable qu’un champ public. Ajoute des vérifications lorsqu’une modification est soumise à des restrictions. Envisage aussi une méthode d’action : celebrateBirthday() exprime l’augmentation de l’âge d’un an et lend() exprime une tentative de prêt. lend() peut examiner l’état courant et refuser un deuxième prêt. Un mutateur peut aussi effectuer cette vérification ; le nom de l’action rend l’opération plus claire pour son appelant.

Un accesseur peut calculer un résultat. getArea() peut renvoyer le produit de la largeur par la hauteur sans aucun champ area.

Un invariant est une règle sur l’état d’un objet qui reste vraie après la construction et après chaque opération publique. Un thermostat peut autoriser des températures cibles de 5 °C à 30 °C. Chaque moyen de définir sa cible doit respecter cet intervalle.

Choisis comment traiter une entrée invalide

Trois réponses utiles consistent à conserver l’ancienne valeur, à ramener la valeur à une borne ou à lever une exception. Leurs effets sont différents : choisis donc une réponse claire pour chaque opération.

Pour un âge d’animal qui ne doit pas être négatif, un mutateur qui ignore les valeurs invalides peut effectuer l’affectation uniquement dans if (age >= 0). Si l’âge stocké est 4, setAge(-2) le laisse à 4. Il ne le remplace pas par 0.

Place les vérifications d’intervalle dans la classe

public static final int MIN_CELSIUS = 5;
public static final int MAX_CELSIUS = 30;
private int target;

public void setTarget(int celsius) {
    if (celsius < MIN_CELSIUS) {
        this.target = MIN_CELSIUS;
    } else if (celsius > MAX_CELSIUS) {
        this.target = MAX_CELSIUS;
    } else {
        this.target = celsius;
    }
}

public void raise() {
    setTarget(this.target + 1);
}

En partant de 20 °C, setTarget(35) stocke 30. setTarget(-3) stocke 5. Après setTarget(29), un appel à raise() stocke 30 ; un autre appel stocke encore 30. Réutiliser le mutateur empêche raise() de dépasser la borne supérieure.

Des vérifications uniquement dans Main ne peuvent pas protéger le thermostat. Un autre appelant pourrait les oublier. La classe doit vérifier la donnée à l’endroit où elle contrôle son stockage.

Valide aussi l’état initial

public Thermostat(int target) {
    setTarget(target);
}

Avec ce constructeur qui effectue un écrêtage, new Thermostat(50) aboutit à 30 °C. Affecter directement this.target = target; autoriserait un état initial invalide de 50. Une méthode privée de vérification partagée est une autre façon de réutiliser la validation dans les constructeurs et les méthodes ultérieures.

Lever une exception est utile lorsqu’un argument invalide révèle une erreur de programmation. Par exemple, un constructeur peut rejeter un compte négatif avec throw new IllegalArgumentException("count must not be negative");. L’objet n’est pas construit avec succès, donc aucun objet terminé invalide n’est transmis à l’appelant. Ignorer une entrée est plus simple mais silencieux ; l’appelant peut avoir besoin d’un autre moyen de remarquer que rien n’a changé.

Garde les données internes mutables à l’intérieur

Une liste privée peut tout de même être exposée si un accesseur renvoie la liste originale. Un appelant pourrait alors ajouter ou supprimer des éléments sans utiliser les méthodes de la classe, en contournant une règle de taille maximale.

Pour un champ ArrayList<String> nommé tracks, return new ArrayList<>(this.tracks); fournit une liste distincte contenant les mêmes chaînes. Modifier cette liste renvoyée ne change pas la liste interne. Des opérations comme addTrack(String title) permettent de garder les modifications de la liste dans la classe et d’en vérifier les règles avant de les accepter.

Un objet utile devrait être facile à examiner sous forme de texte. La méthode Java intégrée toString() renvoie un nom de classe, un signe @ et un code de hachage hexadécimal, par exemple Pet@8bcc55f. Un paquetage nommé fait partie du nom de la classe. Le texte du code de hachage varie et donne généralement peu d’informations sur l’état de l’objet.

Renvoie une description lisible

@Override
public String toString() {
    return this.name + " (" + this.species + ", "
        + this.age + " years)";
}

Pour Luna, une chatte âgée de 3 ans, la chaîne renvoyée est "Luna (cat, 3 years)". La méthode lit les champs et construit une chaîne. Elle ne modifie pas l’animal et n’affiche rien à l’écran.

@Override demande au compilateur de vérifier que la déclaration remplace bien une méthode existante. Cela permet de détecter des erreurs comme écrire tostring avec un s minuscule. L’annotation ne formate pas le résultat à ta place ; c’est l’expression de retour qui détermine le texte.

Reconnais les appels automatiques

System.out.println(luna);
String label = "Pet: " + luna;
String details = luna.toString();

La première ligne affiche la description lisible de l’animal. La deuxième construit "Pet: Luna (cat, 3 years)". La troisième demande explicitement la même description et la stocke sans l’afficher. Lorsqu’une ArrayList d’animaux est affichée, son affichage utilise la méthode toString() de chaque animal entre les crochets de la liste.

La conversion automatique explique pourquoi il est important de renvoyer du texte. L’appelant peut afficher, stocker ou concaténer le résultat. Une méthode qui ne fait qu’afficher ne peut pas fournir la chaîne dont tous ces appelants ont besoin.

Respecte l’en-tête de la méthode

Utilise l’en-tête exact sans argument et inclus l’annotation. Une surcharge avec paramètres peut être une méthode distincte valide, mais l’affichage d’un objet ne fournit pas ces paramètres.

Formate les valeurs sans les modifier

Une horloge a besoin d’heures et de minutes à deux chiffres. Dans sa méthode toString() :

return String.format(java.util.Locale.US,
    "%02d:%02d", this.hours, this.minutes);

Pour 9 heures et 5 minutes, la chaîne est "09:05". Chaque %02d formate un entier sur au moins deux positions, en ajoutant un zéro initial si nécessaire. String.format(java.util.Locale.US, "%.2f", 7.5) renvoie "7.50". Fournir les paramètres régionaux rend la sortie avec point décimal indépendante des paramètres régionaux de formatage par défaut de l’ordinateur.

Garde une description assez courte pour être lue pendant le débogage. Elle peut révéler un état non initialisé : concaténer un champ de nom valant null à une chaîne produit le texte "null", ce qui te ramène à l’initialisation. La description devrait rendre compte de l’état courant : afficher deux fois l’objet ne devrait donc pas faire avancer une horloge ni fêter un anniversaire.

Commence par déterminer ce qu’un objet doit mémoriser, ce que les appelants peuvent lui demander de faire et quels états doivent être autorisés. Transforme ensuite chaque élément en champs, constructeurs et méthodes.

Tire la conception d’une description

« Un livre de bibliothèque a un titre, un auteur et un nombre de pages. Il peut être prêté et rendu. Il ne peut pas être prêté à nouveau tant qu’il est déjà en prêt. »

Utilise LibraryBook comme nom de classe. Stocke les trois valeurs descriptives et un état de prêt booléen. Le titre, l’auteur et le nombre de pages restent fixes : rends-les donc final. L’état du prêt change par des actions qui ont un sens. Un mutateur pour chaque champ est inutile.

Construis la classe complète

public class LibraryBook {
    private final String title;
    private final String author;
    private final int pages;
    private boolean lentOut;

    public LibraryBook(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.lentOut = false;
    }

    public boolean isLentOut() {
        return this.lentOut;
    }

    public boolean lend() {
        if (this.lentOut) {
            return false;
        }
        this.lentOut = true;
        return true;
    }

    public void giveBack() {
        this.lentOut = false;
    }

    @Override
    public String toString() {
        String status = this.lentOut ? "lent out" : "available";
        return this.title + " by " + this.author + ", "
            + this.pages + " pages, " + status;
    }
}

Le constructeur rend le livre disponible. lend() vérifie l’état existant avant de le modifier ; renvoyer false lors d’un deuxième prêt préserve la règle. giveBack() rend le livre disponible. L’accesseur indique son état et toString() décrit le livre entier sans le modifier.

Écris les résultats attendus avant d’exécuter les appels

Dans la méthode main classique d’une classe Main distincte :

LibraryBook b = new LibraryBook("Night Train", "A. Rivera", 320);
System.out.println(b);        // Night Train by A. Rivera, 320 pages, available
System.out.println(b.lend()); // true
System.out.println(b.lend()); // false
b.giveBack();
System.out.println(b.lend()); // true

La deuxième tentative de prêt est essentielle : une méthode qui définit toujours l’indicateur et renvoie true réussirait le premier appel mais échouerait à cette vérification. Teste l’état ainsi que les valeurs de retour avec isLentOut(). Essaie aussi un deuxième livre pour vérifier que le prêt de l’un laisse l’autre disponible.

Teste les points où le comportement change

Couvre chaque constructeur et chaque méthode publique. Pour les vérifications d’intervalle, essaie les deux bornes et des valeurs juste à l’extérieur. Pour une horloge, vérifie le passage à l’heure suivante et le passage à minuit. Pour un mutateur qui rejette ou ignore une entrée invalide, vérifie qu’elle a l’effet annoncé sur l’ancien état. Écris d’abord le résultat attendu pour qu’une sortie inattendue ne devienne pas discrètement ta nouvelle attente.

Construis par petites étapes : les champs et le constructeur d’abord, puis une description lisible, puis une opération et ses vérifications à la fois. Enregistre les classes publiques ordinaires dans des fichiers de noms correspondants, compile-les ensemble et exécute la classe qui contient main. Séparer les opérations du modèle de l’affichage à l’écran permet à la même classe de servir dans différents programmes.