Surcharge de méthodes (overloading)

1. Surcharge de méthodes

La surcharge de méthodes (method overloading) est la possibilité de déclarer dans une même classe plusieurs méthodes portant le même nom mais avec des listes de paramètres différentes (types, nombre ou ordre des arguments). Lorsque vous appelez une telle méthode, le compilateur décide lui‑même quelle version utiliser en fonction des arguments transmis.

Analogie du quotidien

Imaginez que vous appelez le service clientèle d’une banque. Vous pouvez composer des numéros différents — pour les particuliers, pour les entreprises, pour les clients VIP. Les numéros diffèrent, mais l’objectif est le même — obtenir de l’aide. En programmation, la surcharge de méthodes, c’est comme un unique numéro d’assistance qui vous connecte automatiquement au bon opérateur selon votre question (ou les paramètres que vous avez fournis).

Syntaxe de la surcharge en Java

En Java, la surcharge de méthodes est très simple : vous déclarez plusieurs méthodes avec le même nom mais des paramètres différents.

Règle importante :
La surcharge se distingue uniquement par la liste des paramètres (type, nombre, ordre).
La surcharge uniquement par le type de retour n’est pas autorisée !
Le compilateur ne pourra pas distinguer les méthodes si elles ont le même nom et les mêmes paramètres, même si le type de retour diffère.

Exemple simple

public class Printer {
    // Affichage d'un entier
    void print(int x) {
        System.out.println("int: " + x);
    }

    // Affichage d'une chaîne
    void print(String s) {
        System.out.println("String: " + s);
    }

    // Affichage de deux nombres
    void print(int x, int y) {
        System.out.println("int, int: " + x + ", " + y);
    }
}

Utilisation :

Printer printer = new Printer();
printer.print(42);           // appellera print(int x)
printer.print("Hello!");     // appellera print(String s)
printer.print(5, 10);        // appellera print(int x, int y)

Le compilateur détermine automatiquement quelle méthode appeler en fonction des arguments passés.

2. Comment le compilateur choisit la bonne méthode

Lorsque vous appelez une méthode surchargée, le compilateur analyse la liste des arguments et cherche la version la plus appropriée.

Critères de sélection :

• Correspondance du nombre d’arguments.
• Correspondance du type de chaque argument (ou possibilité de conversion, par exemple, int → double).
• S’il y a plusieurs candidats, le plus spécifique est choisi.

Exemple :

public class OverloadDemo {
    void show(int x) {
        System.out.println("show(int): " + x);
    }

    void show(double x) {
        System.out.println("show(double): " + x);
    }

    public static void main(String[] args) {
        OverloadDemo demo = new OverloadDemo();
        demo.show(5);      // show(int): 5
        demo.show(5.5);    // show(double): 5.5
    }
}

Si vous appelez demo.show(5), le compilateur choisira show(int). Si vous l’appelez avec 5.5 — il choisira show(double).

Conversions de types

S’il n’existe pas de méthode appropriée, le compilateur essaiera de convertir les types des arguments (par exemple, int → double), mais uniquement si c’est possible et sans ambiguïté.

void print(double x) { /* ... */ }

print(5); // int 5 est converti en double 5.0

La surcharge uniquement par le type de retour — ne fonctionne pas !

Beaucoup de débutants essaient de faire ceci :

// Erreur ! Une telle surcharge est impossible
int sum(int x, int y) { return x + y; }
double sum(int x, int y) { return (double) (x + y); }

Le compilateur ne comprendra pas quelle méthode vous souhaitez appeler si vous écrivez simplement sum(2, 3).
Retenez : la surcharge de méthodes n’est possible que par les paramètres, pas par le type de retour !

3. Surcharge des constructeurs

On peut surcharger non seulement les méthodes ordinaires, mais aussi les constructeurs !

public class Person {
    String name;
    int age;

    // Constructeur avec uniquement le nom
    public Person(String name) {
        this.name = name;
        this.age = 0; // par défaut
    }

    // Constructeur avec nom et âge
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Utilisation :

Person p1 = new Person("Anna");
Person p2 = new Person("Boris", 25);

4. Exemples pratiques

Calculator avec surcharge

Écrivons une classe Calculator capable d’additionner des nombres de types et de quantités différents.

public class Calculator {
    // Addition de deux entiers
    int add(int a, int b) {
        return a + b;
    }

    // Addition de trois entiers
    int add(int a, int b, int c) {
        return a + b + c;
    }

    // Addition de deux doubles
    double add(double a, double b) {
        return a + b;
    }
}

Utilisation :

Calculator calc = new Calculator();

System.out.println(calc.add(2, 3));         // 5
System.out.println(calc.add(1, 2, 3));      // 6
System.out.println(calc.add(2.5, 3.1));     // 5.6

Surcharge de méthodes dans la bibliothèque standard

Vous avez déjà rencontré la surcharge, même sans vous en rendre compte. Par exemple, la méthode println dans System.out est surchargée pour différents types :

System.out.println("Hello");   // println(String)
System.out.println(123);       // println(int)
System.out.println(3.14);      // println(double)
System.out.println(true);      // println(boolean)

Ouvrez les sources de la classe PrintStream — vous verrez des dizaines de versions surchargées de println.

5. Quand utiliser la surcharge

La surcharge de méthodes est un outil puissant, mais à utiliser avec discernement. Elle est pratique lorsque :

• La logique de la méthode est identique, mais les paramètres peuvent différer.
• Vous souhaitez rendre l’API de la classe plus conviviale et flexible.
• Vous devez prendre en charge d’anciennes et de nouvelles variantes d’appel de la méthode.

Exemple concret :
Dans notre application d’apprentissage (par exemple, un gestionnaire de tâches), on peut implémenter une méthode pour ajouter une tâche avec des paramètres différents :

public class TaskManager {
    void addTask(String description) { ... }
    void addTask(String description, int priority) { ... }
    void addTask(String description, int priority, String deadline) { ... }
}

Cette approche est non seulement pratique pour l’utilisateur du code, mais elle rend aussi votre classe flexible pour de futures évolutions.

6. Surcharge et varargs (nombre variable d’arguments)

En Java, il est possible de déclarer une méthode avec un nombre variable de paramètres à l’aide de ... (varargs) :

void printAll(String... messages) {
    for (String msg : messages) {
        System.out.println(msg);
    }
}

On peut maintenant l’appeler :

printAll("Hello");
printAll("One", "Two", "Three");

On peut également surcharger avec des varargs, mais attention : s’il existe deux méthodes, et que l’une utilise des varargs tandis que l’autre a un nombre fixe de paramètres, le compilateur tentera d’abord de trouver une correspondance exacte.

7. Erreurs typiques lors de la surcharge de méthodes

Erreur n° 1 : confusion entre les types d’arguments.
Si vous avez les méthodes void process(int x) et void process(double x), l’appel process(5) invoquera la première version, et process(5.0) — la seconde. Mais si vous appelez process(5L), le compilateur cherchera la meilleure correspondance et pourra choisir une surcharge non évidente (ou même signaler une ambiguïté).

Erreur n° 2 : surcharge avec auto-conversion.
Si vous avez void foo(Integer x) et void foo(Long x), l’appel foo(5) entraînera une erreur de compilation — le compilateur ne sait pas quelle méthode choisir, car 5 peut être converti aussi bien en Integer qu’en Long.

Erreur n° 3 : surcharge uniquement par type de retour.
Comme mentionné plus haut, des méthodes qui ne diffèrent que par le type de retour ne peuvent pas être surchargées.

Erreur n° 4 : surcharge et héritage.
Si une méthode est déclarée dans la classe de base et que, dans une sous-classe, vous déclarez une méthode portant le même nom mais avec une signature différente, il s’agit d’une surcharge et non d’une redéfinition. On confond souvent les deux ! Plus de détails dans la prochaine leçon.