Qu'est-ce qu'une Méthode en Java ?

En programmation Java, une méthode est un bloc de code nommé qui encapsule une série d'opérations conçues pour accomplir une tâche spécifique. Elle représente le comportement ou l'action qu'un objet peut effectuer. Le principe de responsabilité unique suggère qu'une méthode devrait idéalement se concentrer sur une seule tâche bien définie pour maintenir la clarté et faciliter la maintenance.

Anatomie d'une Méthode

La syntaxe générale pour définir une méthode en Java est la suivante :

ModificateurAcces ModificateurSpecial TypeRetour NomMethode(TypeParametre nomParametre1, TypeParametre nomParametre2, ...) {
    // Corps de la méthode : instructions à exécuter
    // ...
    // Instruction de retour (obligatoire si TypeRetour n'est pas 'void')
    return valeurDeRetour; 
}

Modificateurs d'Accès

Les modificateurs d'accès définissent la visibilité d'une méthode, contrôlant où elle peut être appelée. Il existe quatre types principaux :

Notez que les méthodes dans les interfaces sont implicitement public, même si le modificateur n'est pas explicitement déclaré.

Modificateurs Spéciaux

Des modificateurs comme final, static et abstract peuvent être appliqués aux méthodes pour ajouter des comportements spécifiques, tels que la prévention de la redéfinition (final), l'association à la classe plutôt qu'à une instance (static), ou la déclaration d'une méthode sans implémentation (abstract). Ces concepts seront explorés en détail ultérieurement dans le cadre de la programmation orientée objet.

Type de Retour

Le TypeRetour spécifie le type de données que la méthode renverra après son exécution. Si une méthode n'est pas censée renvoyer de valeur, son type de retour doit être void. Le type de retour peut être un type primitif (comme int, double) ou un type de référence (comme String, Object ou toute autre classe).

Nom de la Méthode

Le NomMethode est un identifiant unique qui doit clairement décrire l'objectif de la méthode. Selon les conventions de nommage Java, les noms de méthodes commencent par une lettre mniuscule et suivent la convention camelCase (ex: calculerSomme, afficherDetailsProduit).

Paramètres

Les paramètres (ou arguments) sont des variables que la méthode reçoit de l'extérieur pour effectuer ses opérations. Ils sont déclarés entre parenthèses après le nom de la méthode, chacun avec son type et son nom. Par exemple, une méthode pour calculer la somme de deux nombres pourrait être définie comme suit :

public class Calculatrice {
    public int additionner(int a, int b) {
        return a + b;
    }

    public double calculerMoyenne(double valeur1, double valeur2, double valeur3) {
        return (valeur1 + valeur2 + valeur3) / 3;
    }
}

L'ordre et le nombre des paramètres sont importants lors de l'appel de la méthode.

Catégories de Méthodes en Java

Les méthodes en Java peuvent être classées en trois catégories principales :

1. Méthodes Statiques (de Classe)

Une méthode statique est une méthode qui appartient à la classe elle-même, plutôt qu'à une instance spécifique de cette classe. Elle est déclarée avec le mot-clé static. La méthode main est l'exemple le plus courant de méthode statique, point d'entrée de toute application Java.

public class UtilitaireMath {
    // Méthode statique pour calculer le carré d'un nombre
    public static int carre(int nombre) {
        return nombre * nombre;
    }

    public static void main(String[] args) {
        int resultat = UtilitaireMath.carre(5); // Appel direct via le nom de la classe
        System.out.println("Le carré de 5 est : " + resultat); // Affiche 25
    }
}

2. Méthodes d'Instance

Les méthodes d'instance appartiennent à un objet spécifique (une instance de classe). Pour appeler une méthode d'instance, il faut d'abord créer un objet de la classe à laquelle la méthode appartient. Elles opèrent généralement sur les données (champs) de l'objet.

public class Produit {
    private String nom;
    private double prix;

    public Produit(String nom, double prix) {
        this.nom = nom;
        this.prix = prix;
    }

    // Méthode d'instance pour afficher les détails du produit
    public void afficherDetails() {
        System.out.println("Nom du produit : " + nom + ", Prix : " + prix + " €");
    }

    public double getPrixAvecTaxe(double tauxTaxe) {
        return prix * (1 + tauxTaxe);
    }
}

3. Constructeurs

Un constructeur est une méthode spéciale utilisée pour initialiser un nouvel objet d'une classe. Il est appelé automatiquement lors de la création d'une instance de classe à l'aide de l'opérateur new. Les caractéristiques clés d'un constructeur sont :

• Son nom doit être identique au nom de la classe (respectant la casse).
• Il n'a pas de type de retour (pas même void).
• Il peut être surchargé (plusieurs constructeurs avec des listes de paramètres différentes).
• Il peut avoir des modificateurs d'accès.

public class Article {
    String reference;
    String description;
    double poids;

    // Constructeur par défaut (sans arguments)
    public Article() {
        this.reference = "INCONNU";
        this.description = "Aucune description";
        System.out.println("Un nouvel article a été créé (constructeur par défaut).");
    }

    // Constructeur avec un argument
    public Article(String ref) {
        this.reference = ref;
        this.description = "Description standard";
        System.out.println("Article créé avec référence : " + ref);
    }

    // Constructeur avec plusieurs arguments
    private Article(String ref, String desc, double pds) {
        this.reference = ref;
        this.description = desc;
        this.poids = pds;
        System.out.println("Article complet créé : " + ref + " (" + desc + ")");
    }
}

Invocation des Méthodes

La manière d'appeler une méthode dépend de sa catégorie.

Appel de Méthodes Statiques

Les méthodes statiques sont invoquées directement via le nom de la classe, sans avoir besoin d'une instance de l'objet. Si la méthode statique est appelée depuis la même classe, le nom de la classe peut être omis.

public class Service {
    public static void logMessage(String msg) {
        System.out.println("[LOG] " + msg);
    }

    public static int multiplier(int a, int b) {
        logMessage("Multiplication de " + a + " et " + b); // Appel direct dans la même classe
        return a * b;
    }

    public void demarrerService() {
        logMessage("Démarrage du service..."); // Appel direct dans la même classe (méthode d'instance appelant static)
        int resultat = Service.multiplier(4, 5); // Appel via le nom de la classe
        System.out.println("Résultat de la multiplication : " + resultat);
    }

    public static void main(String[] args) {
        Service.logMessage("Application démarrée."); // Appel via le nom de la classe
        Service monService = new Service();
        monService.demarrerService();
    }
}

Appel de Méthodes d'Instance

Les méthodes d'instance nécessitent la création d'un objet (une instance de classe) avant de pouvoir être appelées. Elles sont invoquées à l'aide de la syntaxe nomObjet.nomMethode(arguments). Dans la même classe, une méthode d'instance peut appeler une autre méthode d'instance directement, sans préfixe d'objet (implicitement this.nomMethode()).

public class CompteBancaire {
    private String titulaire;
    private double solde;

    public CompteBancaire(String titulaire, double soldeInitial) {
        this.titulaire = titulaire;
        this.solde = soldeInitial;
        System.out.println("Compte créé pour " + titulaire + " avec solde " + soldeInitial + "€");
    }

    public void deposer(double montant) {
        if (montant > 0) {
            solde += montant;
            afficherSolde(); // Appel d'une autre méthode d'instance de la même classe
        }
    }

    public void retirer(double montant) {
        if (montant > 0 && solde >= montant) {
            solde -= montant;
            afficherSolde();
        } else {
            System.out.println("Opération de retrait impossible.");
        }
    }

    private void afficherSolde() {
        System.out.println("Solde actuel pour " + titulaire + " : " + solde + "€");
    }

    public static void main(String[] args) {
        CompteBancaire monCompte = new CompteBancaire("Alice Dupont", 1000.0);
        monCompte.deposer(200.0); // Appel de méthode d'instance via l'objet
        monCompte.retirer(500.0);
    }
}

Appel de Constructeurs

Les constructeurs sont appelés via l'opérateur new pour créer une nouvelle instance d'une classe. On utilise la syntaxe NomClasse nomObjet = new Constructeur(arguments);.

Il est également possible d'appeler un autre constructeur de la même classe depuis un constructeur en utilisant this(...). Cette instruction doit impérativement être la première ligne du constructeur appelant.

public class Document {
    String titre;
    String auteur;
    int anneePublication;

    // Constructeur principal
    public Document(String titre, String auteur, int anneePublication) {
        this.titre = titre;
        this.auteur = auteur;
        this.anneePublication = anneePublication;
        System.out.println("Document '" + titre + "' créé par " + auteur + " (" + anneePublication + ").");
    }

    // Constructeur simplifié appelant le constructeur principal
    public Document(String titre, String auteur) {
        this(titre, auteur, java.time.Year.now().getValue()); // Appel à un autre constructeur (doit être la 1ère ligne)
        System.out.println("Version simplifiée du document créée.");
    }

    // Constructeur par défaut
    public Document() {
        this("Sans titre", "Anonyme"); // Appel à un autre constructeur
    }

    public static void main(String[] args) {
        Document doc1 = new Document("Le Monde de Java", "John Doe", 2023); // Appel du constructeur principal
        Document doc2 = new Document("Guide Rapide Java", "Jane Smith"); // Appel du constructeur simplifié
        Document doc3 = new Document(); // Appel du constructeur par défaut
    }
}