Les classes en Java : définir des champs, des méthodes et des objets

Une classe est un plan

Jusqu'à présent, votre code vivait dans des méthodes qui se passaient de simples valeurs. Une classe vous permet de regrouper des données liées et le comportement qui agit sur elles au sein d'un seul type nommé. La classe est le plan ; les choses réelles avec lesquelles vous travaillez sont les objets créés à partir d'elle.

Une classe déclare deux sortes de membres : les champs (les données que détient chaque objet) et les méthodes (ce que chaque objet sait faire).

class Dog {
    String name;          // un champ : chaque Dog a un nom
    int age;              // un autre champ

    void bark() {         // une méthode : un comportement de chaque Dog
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // crée un objet à partir du plan
        d.name = "Rex";       // affecte ses champs
        d.age = 3;
        d.bark();             // appelle sa méthode
    }
}

new Dog() construit un objet en mémoire et vous remet une référence vers lui. d.name et d.bark() accèdent à cet objet précis.

Chaque objet a son propre état

Tout l'intérêt d'une classe est que vous pouvez produire de nombreux objets indépendants, chacun portant ses propres valeurs de champs. En modifier un n'en touche jamais un autre.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex et bella sont deux objets distincts. Chacun a son propre name, donc chaque bark() affiche une valeur différente. Ces données propres à chaque objet s'appellent l'état d'instance.

Champs et méthodes fonctionnent ensemble

Les méthodes d'une classe peuvent lire et mettre à jour directement les champs de l'objet, sans avoir à les passer en paramètres. La méthode « vit déjà sur » l'objet dont elle manipule les données.

class Counter {
    int count;            // vaut 0 par défaut

    void increment() {
        count++;          // met à jour le champ de cet objet
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

Remarquez que increment() ne prend aucun argument. Elle agit sur le champ appartenant au Counter sur lequel vous l'avez appelée. C'est là la différence entre une méthode de classe et une méthode statique isolée : la méthode dispose d'un objet implicite sur lequel agir.

Le mot-clé this

À l'intérieur d'une méthode, this est une référence vers l'objet sur lequel la méthode a été appelée. En général, vous n'en avez pas besoin : écrire count signifie déjà this.count. Mais this devient indispensable lorsqu'un nom de paramètre entre en collision avec un nom de champ, ce qui arrive constamment dans les setters et les constructeurs.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x est le champ ; x est le paramètre
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

Une erreur classique de débutant consiste à écrire x = x; dans move. Cela ne fait qu'affecter le paramètre à lui-même et laisse le champ intact : le compilateur ne vous avertit pas et votre objet conserve silencieusement ses anciennes valeurs. C'est this.x = x; qui met réellement à jour le champ.

Valeurs par défaut des champs et références null

Lorsque vous créez un objet, ses champs ne contiennent pas n'importe quoi : Java les initialise à des valeurs par défaut : 0 pour les nombres, false pour boolean et null pour les références d'objets comme String. Cette valeur par défaut null est à l'origine d'un plantage classique.

class User {
    String name;          // non affecté, donc null par défaut
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name vaut null parce que personne ne l'a affecté, donc appeler .length() dessus lève une NullPointerException. Affectez toujours des valeurs pertinentes à un objet avant d'utiliser ses champs, ce qui est précisément le problème que résolvent les constructeurs.

Organiser le code autour des classes

Les vrais programmes modélisent leur domaine sous forme de classes qui regroupent les données et les opérations qui s'y appliquent. Ici, une seule classe BankAccount conserve un solde et encadre la façon dont il évolue :

class BankAccount {
    String owner;
    double balance;

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // fonds insuffisants
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

Les données (balance) et les règles qui les modifient (deposit, withdraw) vivent au même endroit. Le code extérieur demande au compte d'effectuer des actions plutôt que de manipuler directement ses chiffres : c'est le fondement d'une conception propre et maintenable.

Suite : les constructeurs

Affecter chaque champ à la main après new est fastidieux et facile à oublier et, comme vous venez de le voir, un champ oublié laisse un null prêt à provoquer un plantage. Un constructeur vous permet d'exiger et d'initialiser les champs d'un objet au moment même de sa création, de sorte qu'un BankAccount ne puisse jamais exister sans propriétaire. C'est le sujet de la page suivante.