Maîtriser les méthodes Java : création, invocation et abstraction

Une méthode Java est un ensemble d'instructions regroupées pour effectuer une opération. Lorsque vous appelez System.out.println(), le système exécute en réalité plusieurs instructions pour afficher un message sur la console.

Vous allez apprendre à créer vos propres méthodes (avec ou sans valeur de retour), à les invoquer (avec ou sans paramètres), et à appliquer l'abstraction de méthode dans la conception de programmes.

Création d'une méthode

Syntaxe

public static int nomMethode(int a, int b) {
    // corps de la méthode
}

Détail des composants :

• public static : modificateurs d'accès (optionnels)
• int : type de retour
• nomMethode : nom de la méthode
• a, b : paramètres formels
• int a, int b : liste des paramètres

Structure complète

modificateur typeRetour nomMethode (ListeParamètres) {
    // corps de la méthode
}

La définition d'une méthode comprend :

• modificateur : définit le type d'accès (optionnel)
• typeRetour : la méthode peut retourner une valeur
• nomMethode : le nom de la méthode ; la signature inclut le nom et la liste des paramètres
• ListeParamètres : type, ordre et nombre des paramètres (optionnel, peut être vide)
• corps de la méthode : instructions définissant ce que fait la méthode

Exemple : méthode min()

/** Retourne le minimum entre deux nombres */
public static int minFunction(int n1, int n2) {
    int min;
    if (n1 > n2)
        min = n2;
    else
        min = n1;
    return min;
}

Appel de méthode

Pour utiliser une méthode, il faut l'appeler. Deux cas : la méthode retourne une valeur, ou ne retourne rien (void).

Lorsqu'un programme invoque une méthode, le contrôle est transféré à la méthode appelée. Celle-ci rend le contrôle au code appelant dans deux cas :

• exécution d'une instruction return
• atteinte de l'accolade fermante de la méthode

Les méthodes void s'utilisent comme des instructions :

System.out.println("Bienvenue sur Tutorialspoint !");

Les méthodes retournant une valeur s'utilisent dans des expressions :

int resultat = somme(6, 9);

Exemple complet : définition et appel

public class ExempleMinNombre {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        int c = minFunction(a, b);
        System.out.println("Valeur minimale = " + c);
    }
    
    /** Retourne le minimum de deux nombres */
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
}

Résultat : Valeur minimale = 6

Le mot-clé void

void permet de créer des méthodes sans valeur de retour. Un appel à une méthode void doit être une instruction terminée par un point-virgule.

Exemple

public class ExempleVoid {
    public static void main(String[] args) {
        methodRankPoints(255.7);
    }
    
    public static void methodRankPoints(double points) {
        if (points >= 202.5) {
            System.out.println("Rang : A1");
        } else if (points >= 122.4) {
            System.out.println("Rang : A2");
        } else {
            System.out.println("Rang : A3");
        }
    }
}

Résultat : Rang : A1

Passage de paramètres par valeur

En Java, les arguments sont toujours passés par valeur. L'ordre doit correspondre à la déclaration des paramètres. La méthode reçoit une copie de la valeur ; les modifications à l'intérieur n'affectent pas l'original.

Exemple : tentative d'échange

public class ExempleEchange {
    public static void main(String[] args) {
        int a = 30;
        int b = 45;
        System.out.println("Avant échange : a = " + a + ", b = " + b);
        
        swapFunction(a, b);
        
        System.out.println("Après échange : a = " + a + ", b = " + b);
    }
    
    public static void swapFunction(int a, int b) {
        System.out.println("Dans la méthode - Avant : a = " + a + ", b = " + b);
        int c = a;
        a = b;
        b = c;
        System.out.println("Dans la méthode - Après : a = " + a + ", b = " + b);
    }
}

Résultat :

Avant échange : a = 30, b = 45
Dans la méthode - Avant : a = 30, b = 45
Dans la méthode - Après : a = 45, b = 30
Après échange : a = 30, b = 45

Les valeurs originales restent inchangées car Java passe une copie des valeurs primitives.

Surcharge de méthodes (Overloading)

Une classe peut avoir plusieurs méthodes du même nom mais avec des paramètres différents (nombre, type ou ordre). C'est la surcharge, à ne pas confondre avec le redéfinition (overriding).

Exemple

public class ExempleSurcharge {
    public static void main(String[] args) {
        int a = 11, b = 6;
        double c = 7.3, d = 9.4;
        
        int resultat1 = minFunction(a, b);      // version int
        double resultat2 = minFunction(c, d);   // version double
        
        System.out.println("Minimum (int) : " + resultat1);
        System.out.println("Minimum (double) : " + resultat2);
    }
    
    // Pour entiers
    public static int minFunction(int n1, int n2) {
        return (n1 > n2) ? n2 : n1;
    }
    
    // Pour doubles
    public static double minFunction(double n1, double n2) {
        return (n1 > n2) ? n2 : n1;
    }
}

Résultat :

Minimum (int) : 6
Minimum (double) : 7.3

Arguments de ligne de commande

Pour passer des informations à un programme au lancement, on utilise les arguments de ligne de commande, accessibles via le tableau String[] args de la méthode main.

Exemple

public class LigneCommande {
    public static void main(String args[]) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] : " + args[i]);
        }
    }
}

Exécution : java LigneCommande ceci est un test 200 -100

Résultat :

args[0] : ceci
args[1] : est
args[2] : un
args[3] : test
args[4] : 200
args[5] : -100

Le mot-clé this

this est une référence à l'instance courante, utilisable dans les méthodes d'instance et constructeurs. Il permet :

• de différencier les variables d'instance des variables locales de même nom
• d'appeler un constructeur depuis un autre (invocation explicite)

Différencier variable d'instance et variable locale

class Etudiant {
    int age;
    Etudiant(int age) {
        this.age = age;  // this.age = variable d'instance, age = paramètre
    }
}

Appel de constructeur (this())

class Etudiant {
    int age;
    Etudiant() {
        this(20);  // appelle le constructeur paramétré
    }
    Etudiant(int age) {
        this.age = age;
    }
}

Exemple complet

public class ExempleThis {
    int num = 10;  // variable d'instance
    
    ExempleThis() {
        System.out.println("Exemple avec le mot-clé this");
    }
    
    ExempleThis(int num) {
        this();  // appelle le constructeur par défaut
        this.num = num;  // affecte le paramètre à la variable d'instance
    }
    
    public void saluer() {
        System.out.println("Bienvenue !");
    }
    
    public void afficher() {
        int num = 20;  // variable locale
        System.out.println("Variable locale num : " + num);
        System.out.println("Variable d'instance num : " + this.num);
        this.saluer();
    }
    
    public static void main(String[] args) {
        ExempleThis obj1 = new ExempleThis();
        obj1.afficher();
        
        ExempleThis obj2 = new ExempleThis(30);
        obj2.afficher();
    }
}

Résultat :

Exemple avec le mot-clé this
Variable locale num : 20
Variable d'instance num : 10
Bienvenue !
Exemple avec le mot-clé this
Variable locale num : 20
Variable d'instance num : 30
Bienvenue !

Arguments variables (varargs)

Depuis JDK 1.5, on peut passer un nombre variable d'arguments du même type :

typeNom... nomParametre

Un seul paramètre varargs par méthode, obligatoirement en dernier.

Exemple

public class DemoVarargs {
    public static void main(String args[]) {
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
    
    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("Aucun argument");
            return;
        }
        double max = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > max) max = numbers[i];
        }
        System.out.println("Valeur max : " + max);
    }
}

Résultat :

Valeur max : 56.5
Valeur max : 3.0

La méthode finalize()

Appelée par le ramasse-miettes juste avant la destruction d'un objet. Permet de libérer des ressources (fermer un fichier, etc.).

protected void finalize() {
    // code de finalisation
}

Attention : on ne sait ni quand ni même si finalize() sera exécuté. Si le programme se termine avant le GC, elle ne s'exécutera pas. Préférez try-with-resources ou AutoCloseable pour la gestion de ressources.