Module 3 - Méthodes, Classes et Objets

1. Les Méthodes : Organiser son Code en Blocs Réutilisables

À mesure que les programmes grandissent, la méthode main devient surchargée et difficile à lire. Pour éviter cela et respecter le principe DRY (Don't Repeat Yourself), on divise le code en méthodes. Une méthode est un bloc de code nommé qui accomplit une tâche spécifique et peut être appelé à volonté.

Anatomie Détaillée d'une Méthode

Décortiquons la signature d'une méthode pour bien en comprendre chaque partie :

public static int sum(int a, int b) → public Le modificateur d'accès. Il définit qui peut appeler cette méthode. public signifie qu'elle est accessible depuis n'importe quelle autre classe. → static Un mot-clé crucial. Une méthode static appartient à la classe elle-même, et non à un objet spécifique. → int Le type de retour. C'est la promesse que la méthode fera un calcul et renverra une valeur de ce type. Si elle ne retourne rien, on utilise void. → sum Le nom de la méthode. Par convention, il commence par une minuscule et décrit une action (un verbe). → (int a, int b) La liste des paramètres. Ce sont les "ingrédients" dont la méthode a besoin. → { return a + b; } Le corps de la méthode, où la logique est exécutée. L'instruction return met fin et renvoie la valeur calculée.

Exemple 1 : Création de Méthodes Simples

public class MethodExample {

    // Méthode qui prend deux entiers et retourne leur somme
    public static int sum(int a, int b) {
        return a + b;
    }

    // Méthode qui prend un nom et affiche un message
    public static void greet(String name) {
        System.out.println("Bonjour, " + name + "!");
    }

    public static void main(String[] args) {
        // Appel de la méthode sum et stockage du résultat
        int result = sum(10, 20);
        System.out.println("La somme de 10 et 20 est: " + result);

        // Appel de la méthode greet
        greet("Alice");
    }
}
            

Résultat :

La somme de 10 et 20 est: 30
Bonjour, Alice!
            

Pour aller plus loin :

Source: EvoluNoob

2. La Surcharge de Méthodes (Method Overloading)

La surcharge de méthodes est une fonctionnalité très pratique de Java. Elle permet de définir plusieurs méthodes avec le même nom, à condition que leur signature de paramètres soit différente (soit par le nombre de paramètres, soit par leur type).

Analogie : Pensez aux boutons de votre télécommande. Vous pourriez avoir plusieurs boutons "Play" : un pour le lecteur Blu-ray, un pour Netflix, un pour une clé USB. Vous appelez la même "action" (Play), mais le système sait laquelle exécuter en fonction du contexte (l'appareil actif).

Exemple 2 : Surcharge de la Méthode add

public class MethodOverloading {

    // Version 1 : additionne deux entiers
    public static int add(int a, int b) {
        return a + b;
    }

    // Version 2 : surcharge avec trois entiers
    public static int add(int a, int b, int c) {
        return a + b + c;
    }

    // Version 3 : surcharge avec deux doubles
    public static double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println("Addition de deux entiers: " + add(5, 10));
        System.out.println("Addition de trois entiers: " + add(1, 2, 3));
        System.out.println("Addition de deux doubles: " + add(4.5, 6.7));
    }
}
            

Le compilateur Java est assez intelligent pour appeler la bonne version de la méthode add en se basant sur les arguments que vous lui fournissez.

Pour aller plus loin :

Source: EvoluNoob

3. La Révolution : Penser en Termes de Classes et d'Objets

C'est le changement de mentalité le plus important en Java. Au lieu de penser en listes d'instructions, on pense en termes d'entités qui interagissent.

→ Une Classe

C'est un plan de construction, un moule qui définit la structure et le comportement.

Analogie : Le plan d'architecte pour une maison. Il définit que toutes les maisons de ce type auront une cuisine, des chambres et des portes, et qu'on pourra y "entrer" ou "allumer les lumières".

→ Un Objet

C'est une instance concrète créée à partir de ce plan.

Analogie : La maison de Paul et la maison de Marie. Ce sont deux objets distincts, construits à partir du même plan. La maison de Paul peut avoir une cuisine peinte en bleu, celle de Marie en vert. Elles partagent la même structure, mais ont des états différents.

Une classe regroupe deux types d'informations : les attributs (l'état) et les méthodes (le comportement). Créer un objet à partir d'une classe s'appelle l'instantiation, et se fait avec le mot-clé new.

Exemple 3 : La Classe Voiture et sa Création

1. Le plan de construction (Voiture.java)

public class Voiture {
    // Attributs (état de chaque voiture)
    String marque;
    String modele;
    int vitesseActuelle = 0;

    // Méthodes d'instance (comportement)
    // Celles-ci ne sont PAS 'static' car elles agissent sur un objet spécifique
    public void accelerer(int augmentation) {
        this.vitesseActuelle += augmentation;
        System.out.println("La " + this.marque + " accélère. Vitesse : " + this.vitesseActuelle + " km/h.");
    }
}
            

2. Le programme principal qui utilise le plan (Garage.java)

public class Garage {
    public static void main(String[] args) {
        // Instanciation : on crée deux objets Voiture distincts
        Voiture maVoiture = new Voiture();
        maVoiture.marque = "Renault";
        maVoiture.modele = "Clio";

        Voiture taVoiture = new Voiture();
        taVoiture.marque = "Peugeot";
        taVoiture.modele = "208";

        // Chaque objet a sa propre vie et son propre état
        maVoiture.accelerer(50);
        taVoiture.accelerer(30);
    }
}
            

Résultat :

La Renault accélère. Vitesse : 50 km/h.
La Peugeot accélère. Vitesse : 30 km/h.
            

4. Le Constructeur et le Mot-clé this

Imaginez que vous êtes le directeur d'une usine de voitures. Chaque fois qu'une nouvelle voiture sort de la chaîne de montage, elle doit être prête à l'emploi. Le constructeur est l'équivalent de cette chaîne de montage finale. Son rôle est d'initialiser un nouvel objet et de le mettre dans un état cohérent et utilisable dès sa création.

Qu'est-ce qu'un Constructeur ?

Un constructeur est une méthode spéciale qui est appelée automatiquement chaque fois que vous utilisez le mot-clé new pour créer une instance d'une classe. Contrairement aux autres méthodes :

Il n'a pas de type de retour (pas même void)
Son nom doit être identique à celui de la classe

Le Rôle du Mot-clé this

Lorsque vous donnez un nom à un paramètre de votre constructeur, il peut arriver que ce nom soit le même que celui d'un attribut de la classe. C'est là que le mot-clé this entre en jeu pour lever l'ambiguïté.

→ this.marque

Fait référence à l'attribut marque de l'objet en cours de création.

→ marque (sans this)

Fait référence au paramètre marque passé au constructeur.

En utilisant this.marque = marque;, vous dites explicitement à Java : "Prends la valeur du paramètre et attribue-la à l'attribut de cet objet".

Impact sur Votre Code

Sans constructeur (fastidieux et sujet aux erreurs) :

Voiture maVoiture = new Voiture();
maVoiture.marque = "Renault";
maVoiture.modele = "Clio";
maVoiture.vitesseActuelle = 0;
            

Avec constructeur (plus propre et sécurisé) :

Voiture maVoiture = new Voiture("Renault", "Clio");

Exemple 4 : Classe Voiture avec un Constructeur

public class Voiture {
    String marque;
    String modele;
    int vitesseActuelle;

    // Le Constructeur
    public Voiture(String marque, String modele) {
        System.out.println("Construction d'une " + marque + " " + modele + "...");
        this.marque = marque;
        this.modele = modele;
        this.vitesseActuelle = 0;
    }

    public void accelerer(int augmentation) {
        this.vitesseActuelle += augmentation;
        System.out.println("La " + this.marque + " accélère. Vitesse : " + this.vitesseActuelle + " km/h.");
    }
}

public class Garage {
    public static void main(String[] args) {
        Voiture maVoiture = new Voiture("Renault", "Clio");
        Voiture taVoiture = new Voiture("Peugeot", "208");

        maVoiture.accelerer(50);
        taVoiture.accelerer(30);
    }
}
            

Résultat :

Construction d'une Renault Clio...
Construction d'une Peugeot 208...
La Renault accélère. Vitesse : 50 km/h.
La Peugeot accélère. Vitesse : 30 km/h.
            

Pour aller plus loin :

Source: EvoluNoob

5. static vs. Instance : La Différence Fondamentale

Comprendre la différence entre les membres statiques et les membres d'instance est crucial en Java. Cette distinction est au cœur du modèle de programmation orientée objet. En substance, cela se résume à une question simple : la méthode ou la variable est-elle liée à un objet spécifique ou à la classe elle-même ?

Méthodes et Attributs d'Instance (Non-statiques)

Les membres d'instance (méthodes et attributs) appartiennent à un objet particulier. Chaque fois que vous créez un nouvel objet, il a sa propre copie des attributs d'instance.

Analogie Imaginez la classe Voiture. Chaque voiture que vous fabriquez est un objet distinct. Chaque voiture a sa propre couleur (un attribut d'instance) et sa propre méthode accelerer() (une méthode d'instance). L'action d'accélérer ne peut être effectuée que sur une voiture spécifique.

Utilisation : Pour accéder à un membre d'instance, vous devez d'abord créer un objet de la classe, puis utiliser l'opérateur point (.) sur cet objet.

Voiture maVoiture = new Voiture("Renault", "Clio");
maVoiture.accelerer(50);
            

Méthodes et Attributs de Classe (static)

Les membres statiques (ou membres de classe) appartiennent à la classe elle-même, et non à un objet. Il n'existe qu'une seule copie de ces membres, partagée par toutes les instances de la classe.

Analogie : Pensez à la classe Math de Java. Elle contient des méthodes comme Math.sqrt() (racine carrée) ou Math.abs() (valeur absolue). Pour calculer la racine carrée de 25, vous n'avez pas besoin de créer un objet "Math". La méthode sqrt() est un outil universel qui appartient à la classe Math.

Utilisation : Les membres statiques sont appelés directement sur la classe en utilisant le nom de la classe, sans avoir besoin de créer un objet.

double resultat = Math.sqrt(25);
System.out.println(resultat); // Affiche 5.0
            

Résumé : Quand Utiliser Quoi ?

Règle Simple à Retenir

Si un membre a besoin de l'état d'un objet pour fonctionner (il utilise les attributs de l'objet), il doit être d'instance.

S'il s'agit d'une fonction utilitaire ou d'une constante qui n'a pas besoin d'un objet pour exister, il doit être statique.

Exercices Pratiques : De la Théorie à la Pratique

Il est temps de modéliser le monde qui nous entoure ! Ces exercices vous guideront dans la création de vos premières classes et objets.

Exercice 1 : Créer une Classe `Personne`

Créez une classe nommée Personne. Cette classe doit avoir deux attributs : nom (de type String) et age (de type int). Elle doit aussi avoir une méthode d'instance nommée sePresenter() qui affiche un message comme "Bonjour, je m'appelle [nom] et j'ai [age] ans."

Dans votre méthode main, créez un objet de type Personne, assignez-lui un nom et un âge, puis appelez sa méthode sePresenter().

Indice : N'oubliez pas de créer un fichier Personne.java pour la classe et un autre fichier avec une méthode main pour l'utiliser.

Voir la solution

// Fichier: Personne.java
public class Personne {
    String nom;
    int age;

    public void sePresenter() {
        System.out.println("Bonjour, je m'appelle " + this.nom + " et j'ai " + this.age + " ans.");
    }
}

// Fichier: Main.java
public class Main {
    public static void main(String[] args) {
        // 1. Création de l'objet (instanciation)
        Personne p1 = new Personne();

        // 2. Assignation des valeurs aux attributs
        p1.nom = "Alice";
        p1.age = 30;

        // 3. Appel de la méthode de l'objet
        p1.sePresenter(); // Affiche: Bonjour, je m'appelle Alice et j'ai 30 ans.
    }
}

Exercice 2 : Ajouter un Constructeur

Reprenez votre classe Personne. Modifiez-la pour y ajouter un constructeur qui accepte un nom et un âge en paramètres. Ce constructeur doit initialiser les attributs de l'objet dès sa création.

Adaptez votre méthode main pour créer une nouvelle personne en utilisant ce constructeur.

Indice : Le constructeur doit avoir le même nom que la classe et utiliser le mot-clé this pour différencier les attributs des paramètres.

Voir la solution

// Fichier: Personne.java
public class Personne {
    String nom;
    int age;

    // Le constructeur
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    public void sePresenter() {
        System.out.println("Bonjour, je m'appelle " + this.nom + " et j'ai " + this.age + " ans.");
    }
}

// Fichier: Main.java
public class Main {
    public static void main(String[] args) {
        // L'objet est créé et initialisé en une seule ligne !
        Personne p2 = new Personne("Bob", 25);
        p2.sePresenter(); // Affiche: Bonjour, je m'appelle Bob et j'ai 25 ans.
    }
}

Exercice 3 : Créer une Classe `CompteBancaire`

Créez une classe CompteBancaire avec un attribut solde (de type double). Ajoutez un constructeur qui initialise le compte avec un solde de départ. Implémentez les méthodes suivantes :

deposer(double montant) : ajoute le montant au solde.
retirer(double montant) : retire le montant du solde, mais seulement si le solde est suffisant.
afficherSolde() : affiche le solde actuel.

Testez votre classe dans le main en créant un compte, en effectuant des dépôts et des retraits (y compris un retrait qui devrait échouer).

Indice : La méthode retirer devra utiliser une condition if pour vérifier si solde >= montant.

Voir la solution

// Fichier: CompteBancaire.java
public class CompteBancaire {
    private double solde;

    public CompteBancaire(double soldeInitial) {
        if (soldeInitial > 0) {
            this.solde = soldeInitial;
        } else {
            this.solde = 0;
        }
    }

    public void deposer(double montant) {
        if (montant > 0) {
            this.solde += montant;
            System.out.println("Dépôt de " + montant + "€. Nouveau solde: " + this.solde + "€");
        }
    }

    public void retirer(double montant) {
        if (montant > 0 && this.solde >= montant) {
            this.solde -= montant;
            System.out.println("Retrait de " + montant + "€. Nouveau solde: " + this.solde + "€");
        } else {
            System.out.println("Opération refusée. Solde insuffisant.");
        }
    }

    public void afficherSolde() {
        System.out.println("Solde actuel: " + this.solde + "€");
    }
}

// Fichier: Main.java
public class Main {
    public static void main(String[] args) {
        CompteBancaire monCompte = new CompteBancaire(100.0);
        monCompte.afficherSolde();  // Affiche 100.0€
        monCompte.deposer(50.0);    // Affiche Dépôt de 50.0€ ... Solde: 150.0€
        monCompte.retirer(20.0);    // Affiche Retrait de 20.0€ ... Solde: 130.0€
        monCompte.retirer(200.0);   // Affiche Opération refusée.
        monCompte.afficherSolde();  // Affiche 130.0€
    }
}