Structure d'une classe : champs, méthodes, constructeurs

1. Champs de classe : où nous stockons l'état de l'objet

Champ — c'est une variable déclarée à l'intérieur d'une classe, mais en dehors de toutes les méthodes. Les champs garantissent que chaque objet possède son propre « état ». Par exemple, si nous avons une classe Person, les champs peuvent être les suivants :

• name — le nom de la personne
• age — l'âge
• balance — le solde du compte (si, par exemple, nous réalisons une application bancaire)
• isStudent — un indicateur indiquant si la personne est étudiante

Syntaxe de déclaration d'un champ

La déclaration d'un champ ressemble à celle d'une variable ordinaire, sauf qu'elle ne se trouve pas dans une méthode, mais directement dans la classe :

public class Person {
    String name;
    int age;
}

Ici, nous avons déclaré deux champs : une chaîne name et un entier age. Chaque champ appartiendra à un objet particulier de cette classe. Cela signifie que différents objets auront leurs propres valeurs. Par exemple :

Person p1 = new Person();
p1.name = "Alice";
p1.age = 20;

Person p2 = new Person();
p2.name = "Bob";
p2.age = 25;

Le premier objet a pour nom « Alice » et pour âge 20, tandis que le second a pour nom « Bob » et 25. Ils sont tous deux créés à partir de la même classe, mais leurs champs stockent des données différentes.

Modificateurs d'accès (public/private)

Les champs peuvent être publics (public) ou privés (private). Dans la vie réelle, vous ne révélez pas votre solde bancaire à n'importe qui, n'est-ce pas ? En programmation, on rend donc souvent les champs private pour empêcher d'y accéder directement depuis d'autres classes. Cela fait partie du principe d'encapsulation (nous y reviendrons dans les prochains cours).

Exemple :

public class Person {
    private String name;
    private int age;
}

Pour l'instant, nous n'allons pas compliquer, mais retenez ceci : si un champ est private, on ne peut pas y accéder directement depuis une autre classe.

2. Méthodes de classe : comment les objets « agissent »

Méthode — c'est une fonction qui décrit le comportement d'un objet. Les méthodes permettent à l'objet de faire quelque chose : parler, calculer, courir, sauter, afficher des informations sur lui-même, etc.

Syntaxe de déclaration d'une méthode

return_type methodName(parameters) {
    // corps de la méthode
}

Exemple de méthode qui dit « Bonjour » :

public void sayHello() {
    System.out.println("Bonjour ! Je m'appelle " + name);
}

Voici :

• public — le modificateur d'accès.
• void — la méthode ne renvoie rien (elle fait simplement quelque chose).
• sayHello — le nom de la méthode.
• À l'intérieur de la méthode, nous utilisons le champ name pour saluer l'utilisateur.

Autre exemple : une méthode qui renvoie l'âge

public int getAge() {
    return age;
}

Les méthodes peuvent renvoyer des valeurs (int, String, etc.), ou ne rien renvoyer — dans ce cas on écrit void.

3. Constructeurs : comment les objets « naissent »

Constructeur — c'est une méthode spéciale appelée lors de la création d'un nouvel objet. Son rôle est d'initialiser les champs de l'objet avec des valeurs initiales, c'est-à-dire de remplir les « petites poches » vides de l'objet avec des données concrètes. Par exemple, attribuer un nom et un âge à une personne dès sa création, plutôt que de les laisser vides.

• Le nom du constructeur coïncide toujours avec le nom de la classe.
• Un constructeur n'a pas de type de retour (même void ne s'écrit pas).
• Les constructeurs peuvent prendre des paramètres (par exemple, nom et âge), ou n'en prendre aucun.

Exemple de constructeur

public class Person {
    String name;
    int age;

    // Constructeur avec deux paramètres
    public Person(String name, int age) {
        this.name = name; // this.name — le champ de l'objet, name — le paramètre du constructeur
        this.age = age;
    }
}

Vous vous demandez probablement ce qu'est this. Eh bien, le mot-clé this est une référence à l'objet courant. De l'intérieur. Nous l'utilisons pour distinguer un champ de classe d'un paramètre portant le même nom. Sans this, le compilateur serait perdu quant à ce que nous voulons initialiser.

Constructeur par défaut

Si vous n'avez déclaré aucun constructeur, le compilateur Java ajoutera automatiquement un constructeur vide sans paramètres. Il ressemble à ceci :

public Person() {
    // ne fait rien, mais permet de créer un objet sans paramètres
}

MAIS ! Si vous avez déclaré au moins un constructeur (par exemple, avec des paramètres), le constructeur par défaut n'est plus créé automatiquement ! S'il vous est nécessaire — écrivez-le explicitement.

4. Exemple de classe complète

Mettons tout ensemble : champs, méthodes, constructeur.

public class Person {
    String name;
    int age;

    // Constructeur
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Méthode : dire bonjour
    public void sayHello() {
        System.out.println("Bonjour ! Je m'appelle " + name + ", j'ai " + age + " ans.");
    }

    // Méthode : augmenter l'âge de 1
    public void haveBirthday() {
        age = age + 1;
        System.out.println("Hourra ! J'ai maintenant " + age + " ans !");
    }
}

Comment l'utiliser dans un programme ?

public class Main {
    public static void main(String[] args) {
        Person john = new Person("John", 18);
        john.sayHello();      // Bonjour ! Je m'appelle John, j'ai 18 ans.
        john.haveBirthday();  // Hourra ! J'ai maintenant 19 ans !
    }
}

5. Pratique : faisons évoluer votre application

Supposons que vous réalisiez une petite application de gestion des utilisateurs. Lors des cours précédents, nous ne travaillions qu'avec des variables et des méthodes à l'intérieur de main. Désormais, créons notre propre classe User avec des champs, des méthodes et un constructeur.

public class User {
    String username;
    int score;

    // Constructeur
    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    // Méthode : afficher les informations de l'utilisateur
    public void printInfo() {
        System.out.println("Nom d'utilisateur : " + username + ", points : " + score);
    }

    // Méthode : augmenter les points
    public void addScore(int points) {
        score += points;
        System.out.println(username + " a obtenu " + points + " points ! Il a maintenant " + score + " points.");
    }
}

Utilisation :

public class Main {
    public static void main(String[] args) {
        User alice = new User("Alice", 10);
        User bob = new User("Bob", 5);

        alice.printInfo(); // Nom d'utilisateur : Alice, points : 10
        bob.printInfo();   // Nom d'utilisateur : Bob, points : 5

        alice.addScore(7); // Alice a obtenu 7 points ! Il a maintenant 17 points.
        bob.addScore(3);   // Bob a obtenu 3 points ! Il a maintenant 8 points.
    }
}

Remarquez : chaque objet possède ses propres champs, et les modifications apportées à l'un n'affectent pas l'autre.

6. En bref sur les modificateurs d'accès

Dans nos exemples, les champs étaient publics (String name;). En pratique, on rend souvent les champs private afin d'éviter de les modifier accidentellement (ou volontairement) depuis une autre classe. Nous verrons cela plus en détail dans le sujet de l'encapsulation, mais voici un exemple :

public class User {
    private String username;
    private int score;

    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    public void printInfo() {
        System.out.println("Nom d'utilisateur : " + username + ", points : " + score);
    }

    public void addScore(int points) {
        score += points;
    }
}

Désormais, si quelqu'un essaie d'écrire alice.score = 100500 ; en dehors de la classe — le compilateur dira « interdit ! ».

7. Erreurs typiques lors de l'utilisation des champs, des méthodes et des constructeurs

Erreur n° 1 : Champs non initialisés.
Si vous ne donnez pas de valeurs aux champs, ils reçoivent des valeurs par défaut : les nombres — 0, boolean — false, les références (par exemple, String) — null. Si vous oubliez d'initialiser un champ, vous pouvez obtenir un résultat inattendu ou même une NullPointerException en essayant de faire quelque chose avec.

Erreur n° 2 : Vous confondez paramètres et champs.
Dans un constructeur, les débutants écrivent souvent simplement name = name ; — cela n'initialise pas le champ, cela assigne simplement le paramètre à lui-même. Utilisez toujours this.name = name !

Erreur n° 3 : Pas de constructeur par défaut.
Si vous avez déclaré un constructeur avec des paramètres mais oublié d'ajouter explicitement un constructeur vide, alors new Person() ne fonctionnera plus.

Erreur n° 4 : Noms identiques pour méthodes et classes.
En Java, le nom d'un constructeur doit coïncider avec le nom de la classe, alors que ce n'est pas le cas pour les méthodes. Parfois, on nomme par erreur une méthode comme la classe, et le compilateur se plaint.

Erreur n° 5 : Oubli des modificateurs d'accès.
Si vous mettez les champs public, on peut les modifier partout — ce qui est dangereux pour les grands programmes. Il vaut mieux s'habituer dès le départ à private et utiliser des méthodes d'accès.