Méthodes en Java — déclaration, paramètres et surcharge

Maîtriser les types primitifs, les variables et la structure de base d'une classe Java. Comprendre les notions de modificateurs d'accès et de mot-clé static.

Objectifs

Déclarer et appeler des méthodes. Distinguer méthodes d'instance et méthodes de classe. Comprendre le passage de paramètres par valeur et par référence. Utiliser les varargs et maîtriser la surcharge de méthodes.

1. Qu'est-ce qu'une méthode ?

Définition — Méthode Une méthode est un module de programme nommé qui regroupe une série d'instructions pour exécuter une tâche précise. Elle peut être appelée un nombre illimité de fois depuis d'autres méthodes. L'utilisation d'un nom de méthode pour encapsuler des instructions est un exemple d'abstraction.

Méthodes et abstraction L'abstraction permet à l'appelant d'utiliser une méthode en connaissant uniquement son nom, ses paramètres et sa valeur de retour — sans connaître les détails internes de son implémentation. C'est le principe du masquage d'implémentation.

2. Structure d'une méthode

Syntaxe — Déclaration d'une méthode Java

modificateur typeRetour nomMethode(typeParam1 param1, typeParam2 param2) {
    // corps de la méthode (implémentation)
    return valeur; // si typeRetour != void
}

2.1 Composants de l'en-tête

Composant	Description	Exemple
Modificateur d'accès	Visibilité : `public`, `private`, `protected`, package	`public`
static (optionnel)	Méthode de classe — appelable sans instance	`public static`
Type de retour	Type de la valeur retournée, ou `void` si aucune	`int`, `String`, `void`
Identificateur	Nom de la méthode — lowerCamelCase, de préférence un verbe	`calculerMoyenne`
Paramètres	Liste des données reçues, séparées par des virgules	`(int a, double b)`

Exemple 1 — Déclaration et appel de méthodes

public class Personne {
    private int    age;
    private String nom;

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

    public void afficher() {
        System.out.println(nom + " (" + age + " ans)");
    }

    public String getNom() {
        return this.nom;
    }

    public static void main(String[] args) {
        Personne p = new Personne(30, "Mostafa");
        p.afficher();
        System.out.println("Nom : " + p.getNom());
    }
}

Sortie

Mostafa (30 ans)
Nom : Mostafa

2.2 Méthodes d'instance vs méthodes de classe

Méthode d'instance vs méthode de classe Une méthode d'instance appartient à un objet — elle nécessite une instance pour être appelée (objet.methode()). Une méthode de classe (déclarée static) appartient à la classe elle-même et peut être appelée sans instance (Classe.methode()).

Exemple 2 — Méthode d'instance vs méthode de classe

class Lampe {
    private boolean isOn;

    public Lampe() {
        this.isOn = false;
    }

    public void allumer() {
        isOn = true;
        System.out.println("Lampe allumée");
    }

    public static void methodeDeClasse() {
        System.out.println("Je suis une méthode de classe");
    }

    public static void main(String[] args) {
        Lampe l = new Lampe();
        l.allumer();

        Lampe.methodeDeClasse();
    }
}

Sortie

Lampe allumée
Je suis une méthode de classe

3. Paramètres et arguments

Argument vs Paramètre Un argument (paramètre réel/effectif) est la valeur passée lors de l'appel de la méthode. Un paramètre (paramètre formel) est la variable déclarée dans l'en-tête de la méthode qui reçoit cette valeur.

Critère	Argument (paramètre réel)	Paramètre (paramètre formel)
Où il apparaît	Dans l'appel de la méthode	Dans la déclaration de la méthode
Rôle	Envoie la valeur à la méthode	Reçoit la valeur de l'argument
Exemple	`afficher(monNom)` → `monNom`	`void afficher(String nom)` → `nom`

Signature d'une méthode La signature d'une méthode est la combinaison de son nom et de la liste de ses paramètres (nombre, types et ordre). Le type de retour ne fait pas partie de la signature. L'appel doit correspondre à la signature.

3.1 Passage par valeur vs passage par référence

Règle de passage en Java En Java, tout est passé par valeur. Cependant :

Pour les types primitifs (int, double…), c'est la valeur elle-même qui est copiée — modifier le paramètre n'affecte pas la variable originale.
Pour les objets, c'est la référence (l'adresse) qui est copiée — les deux références pointent vers le même objet, donc modifier l'état de l'objet via le paramètre est visible chez l'appelant. Mais réaffecter la référence locale n'affecte pas l'originale.

Exemple 3 — Passage par valeur (primitif)

public class TestValeur {

    static void doubler(int x) {
        x = x * 2;
        System.out.println("Dans doubler : x = " + x);
    }

    public static void main(String[] args) {
        int a = 5;
        doubler(a);
        System.out.println("Dans main    : a = " + a);
    }
}

Sortie

Dans doubler : x = 10
Dans main    : a = 5

Exemple 4 — Passage d'objet (référence copiée)

class Personne {
    private String nom;

    public Personne(String nom) { this.nom = nom; }
    public void setNom(String nom) { this.nom = nom; }
    public String getNom() { return nom; }
}

public class TestReference {

    static void changerNom(Personne p, String nouveau) {
        p.setNom(nouveau);
    }

    static void changerReference(Personne p, String nouveau) {
        p = new Personne(nouveau);
    }

    public static void main(String[] args) {
        Personne p = new Personne("ESSADDOUKI");

        changerNom(p, "Kayouh");
        System.out.println("Après changerNom      : " + p.getNom());

        changerReference(p, "Moutawakil");
        System.out.println("Après changerReference : " + p.getNom());
    }
}

Sortie

Après changerNom      : Kayouh
Après changerReference : Kayouh

Explication changerNom modifie l'objet via sa référence copiée — l'effet est visible dans main. changerReference réaffecte la variable locale p à un nouvel objet — cela ne modifie pas la référence originale dans main, qui pointe toujours sur "Kayouh".

4. Arguments variables — Varargs

Varargs (JDK 5+) Les varargs (arguments de longueur variable) permettent à une méthode de recevoir un nombre quelconque d'arguments du même type. La syntaxe utilise trois points ... après le type. En interne, les arguments sont stockés dans un tableau.

Syntaxe — Varargs Java

public void methode(Type... nomTableau) {
    // nomTableau est traité comme un tableau Type[]
}

Exemple 5 — Méthode avec varargs

public class TestVarargs {

    static void afficher(String... noms) {
        System.out.println("Nombre d'arguments : " + noms.length);
        for (String nom : noms) {
            System.out.println("  - " + nom);
        }
    }

    public static void main(String[] args) {
        afficher("Mostafa", "Ismail", "Dounia", "Omar", "Sara");
        System.out.println("---");
        afficher("Un seul nom");
        System.out.println("---");
        afficher();
    }
}

Sortie

Nombre d'arguments : 5
  - Mostafa
  - Ismail
  - Dounia
  - Omar
  - Sara
---
Nombre d'arguments : 1
  - Un seul nom
---
Nombre d'arguments : 0

Exemple 6 — Varargs combiné avec des paramètres fixes

public class TestVarargsMixte {

    static void afficher(int annee, String ecole, String... noms) {
        System.out.println("Année : " + annee + " | École : " + ecole);
        for (String nom : noms) {
            System.out.println("  " + nom);
        }
    }

    public static void main(String[] args) {
        afficher(2025, "UM6P", "Mostafa", "Ismail", "Dounia");
    }
}

Sortie

Année : 2025 | École : UM6P
  Mostafa
  Ismail
  Dounia

Règles des varargs

Il ne peut y avoir qu'un seul paramètre varargs par méthode.
Le varargs doit toujours être le dernier paramètre de la liste.
methode(int a, String... s) est valide — methode(String... s, int a) est une erreur de compilation.

5. Surcharge de méthodes

Définition — Surcharge (Overloading) La surcharge consiste à définir plusieurs méthodes avec le même nom mais des signatures différentes (nombre, types ou ordre des paramètres). Java sélectionne automatiquement la version à appeler selon les arguments fournis.

Exemple 7 — Surcharge de la méthode somme()

public class CalculatriceSOurcharge {

    public int somme(int x, int y) {
        return x + y;
    }

    public int somme(int x, int y, int z) {
        return x + y + z;
    }

    public double somme(double x, double y) {
        return x + y;
    }

    public static void main(String[] args) {
        CalculatriceSOurcharge c = new CalculatriceSOurcharge();
        System.out.println(c.somme(10, 20));       // appelle somme(int, int)
        System.out.println(c.somme(10, 20, 30));   // appelle somme(int, int, int)
        System.out.println(c.somme(10.5, 20.5));   // appelle somme(double, double)
    }
}

Sortie

30
60
31.0

5.1 Règles de résolution de la surcharge

Quand aucune méthode ne correspond exactement au type des arguments, Java effectue des conversions implicites selon cet ordre de priorité :

Priorité	Règle	Exemple
1	Correspondance exacte des types	`afficher(5)` → `afficher(int)`
2	Promotion vers un type plus large dans la même catégorie	`afficher('A')` → `afficher(int)` (char → int)
3	Promotion vers la catégorie supérieure	`afficher(5)` → `afficher(long)` si int absent

5.2 Ce que la surcharge ne peut pas faire

Surcharge par type de retour uniquement — impossible Deux méthodes ne peuvent pas se distinguer uniquement par leur type de retour. Java ne saurait pas laquelle appeler si les paramètres sont identiques.

public int    getValue() { ... }
public String getValue() { ... } // Erreur de compilation !

5.3 Ce que la surcharge peut faire

Question	Réponse
Peut-on surcharger des méthodes statiques ?	Oui — même comportement que les méthodes d'instance
Peut-on surcharger `main()` ?	Oui — mais la JVM n'appelle que `main(String[])`
Java supporte-t-il la surcharge d'opérateurs ?	Non — contrairement à C++, Java ne l'autorise pas
La surcharge est-elle une forme de polymorphisme ?	Oui — c'est le polymorphisme statique (résolu à la compilation)

6. Exercice

Calculatrice avec surcharge et varargs

Niveau : Débutant

Écrire une classe Calculatrice illustrant la déclaration de méthodes, la surcharge et les varargs.

Travail demandé

Déclarer une méthode surchargée max() avec trois versions :
- max(int a, int b) → retourne le plus grand entier
- max(double a, double b) → retourne le plus grand double
- max(int a, int b, int c) → retourne le plus grand parmi trois
Déclarer une méthode somme(int... nombres) utilisant les varargs pour retourner la somme de tous les entiers passés.
Déclarer une méthode statique estPair(int n) qui retourne true si n est pair.
Tester les trois méthodes dans un main.

Sortie attendue

Sortie

max(5, 9)         = 9
max(3.7, 2.1)     = 3.7
max(4, 8, 6)      = 8
somme(1,2,3,4,5)  = 15
somme()           = 0
estPair(10)       = true
estPair(7)        = false

Solution détaillée

public class Calculatrice {

    public int max(int a, int b) {
        return (a > b) ? a : b;
    }

    public double max(double a, double b) {
        return (a > b) ? a : b;
    }

    public int max(int a, int b, int c) {
        return max(max(a, b), c);
    }

    public int somme(int... nombres) {
        int total = 0;
        for (int n : nombres) {
            total += n;
        }
        return total;
    }

    public static boolean estPair(int n) {
        return n % 2 == 0;
    }

    public static void main(String[] args) {
        Calculatrice calc = new Calculatrice();

        System.out.println("max(5, 9)         = " + calc.max(5, 9));
        System.out.println("max(3.7, 2.1)     = " + calc.max(3.7, 2.1));
        System.out.println("max(4, 8, 6)      = " + calc.max(4, 8, 6));
        System.out.println("somme(1,2,3,4,5)  = " + calc.somme(1, 2, 3, 4, 5));
        System.out.println("somme()           = " + calc.somme());
        System.out.println("estPair(10)       = " + estPair(10));
        System.out.println("estPair(7)        = " + estPair(7));
    }
}

Résultat :

Sortie

max(5, 9)         = 9
max(3.7, 2.1)     = 3.7
max(4, 8, 6)      = 8
somme(1,2,3,4,5)  = 15
somme()           = 0
estPair(10)       = true
estPair(7)        = false

Points clés :

Surcharge de max() : Java choisit la version correcte selon les types des arguments — max(5, 9) appelle max(int, int), max(3.7, 2.1) appelle max(double, double).
Réutilisation dans la surcharge : max(int, int, int) réutilise max(int, int) — éviter de dupliquer la logique.
Varargs somme() : peut être appelée avec 0 argument ou plus. Avec 0 arguments, nombres.length == 0 et la boucle ne s'exécute pas → retourne 0.
estPair() statique : appelable directement avec estPair(10) depuis main (même classe) sans passer par un objet.

L'essentiel en bref

Une méthode regroupe des instructions nommées sous un identifiant, permettant leur réutilisation par appel. Son en-tête comprend le modificateur d'accès, le type de retour (void si aucun), le nom et la liste des paramètres. Une méthode d'instance s'appelle via un objet ; une méthode statique s'appelle via la classe. En Java, tout est passé par valeur — pour les objets, c'est la référence qui est copiée, pas l'objet lui-même. Les varargs (Type... nom) acceptent un nombre variable d'arguments, traités comme un tableau — à placer toujours en dernier. La surcharge permet plusieurs méthodes de même nom avec des signatures différentes ; elle ne peut pas se baser uniquement sur le type de retour.

Sortie

// La sortie apparaîtra ici…

Prêt · Ctrl+Entrée pour exécuter

Précédent Modificateurs d'accès en Java - public, private, protec …

Suivant Les constructeurs en Java

Discussion (0)

Soyez le premier à laisser un commentaire !

Laisser un commentaire

Votre commentaire sera visible après modération.

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Méthodes en Java — déclaration, paramètres et surcharge