0Pricing
Java Academy · Leçon

Règles de surcharge des méthodes

Comprenez comment Java résout les méthodes surchargées et les pièges courants liés à l’ambiguïté.

Règles de surcharge des méthodes est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Règles de surcharge de méthode

La surcharge de méthodes permet de définir plusieurs méthodes portant le même nom, mais ayant des listes de paramètres différentes. Java sélectionne la meilleure correspondance au moment de la compilation en appliquant des règles de résolution précises.

Qu'est-ce que la surcharge ?

Les méthodes surchargées partagent un nom, mais diffèrent par le nombre, le type ou l'ordre de leurs paramètres. Le type de retour seul ne suffit pas pour effectuer une surcharge (NOT).

class Calculator {
    int add(int a, int b)     { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c)   { return a + b + c; }

    // compile error — same signature, different return type only:
    // long add(int a, int b) { return a + b; }
}

Calculator calc = new Calculator();
System.out.println(calc.add(1, 2));       // 3 (int)
System.out.println(calc.add(1.5, 2.5));   // 4.0 (double)
System.out.println(calc.add(1, 2, 3));    // 6 (3-arg)

Résolution : correspondance la plus spécifique

Java choisit la méthode applicable la plus spécifique. La conversion d'élargissement, l'encapsulation automatique et les arguments variables sont essayés dans cet ordre de préférence.

static void print(int x)    { System.out.println("int: "    + x); }
static void print(long x)   { System.out.println("long: "   + x); }
static void print(Object x) { System.out.println("Object: " + x); }

print(42);       // int: 42 (exact match — most specific)
print(42L);      // long: 42 (exact match)
print(3.14);     // Object: 3.14 (no float match, widening then autoboxing)

Conversion d'élargissement avant l'encapsulation automatique

Java préfère élargir un type primitif plutôt que de le convertir automatiquement en type enveloppe. Cela peut produire des résultats surprenants.

static void display(long n)    { System.out.println("long: " + n); }
static void display(Integer n) { System.out.println("Integer: " + n); }

int x = 100;
display(x); // long: 100 — widens int to long BEFORE autoboxing to Integer
// This surprises many developers!

static void show(Long n)    { System.out.println("Long"); }
static void show(Integer n) { System.out.println("Integer"); }

// show(100); // compile error — ambiguous! Neither is more specific

Ambiguïté d'un argument nul

Transmettre null à des méthodes surchargées peut être ambigu si plusieurs méthodes acceptent des types de référence. Effectuez une conversion de type de null pour lever l'ambiguïté.

static void handle(String s)  { System.out.println("String: " + s); }
static void handle(Integer i) { System.out.println("Integer: " + i); }
static void handle(Object o)  { System.out.println("Object"); }

handle((String) null);  // String: null (cast resolves ambiguity)
handle((Integer) null); // Integer: null
// handle(null);        // compile error: ambiguous (String vs Integer)

Surcharge avec héritage

La résolution des méthodes tient compte du type déclaré de la variable de référence, et non du type de l'objet au moment de l'exécution : il s'agit d'une décision prise à la compilation.

class Animal {}
class Dog extends Animal {}

static void greet(Animal a) { System.out.println("Animal"); }
static void greet(Dog d)    { System.out.println("Dog"); }

Animal a = new Dog(); // declared as Animal
greet(a);   // Animal — compile-time type is Animal!

Dog d = new Dog();
greet(d);   // Dog — compile-time type is Dog

Surcharge contre redéfinition

La surcharge est une décision prise à la compilation (liaison statique). La redéfinition est une décision prise à l'exécution (liaison dynamique), fondée sur le type réel de l'objet.

class Base {
    void run() { System.out.println("Base.run"); }
}
class Sub extends Base {
    @Override
    void run() { System.out.println("Sub.run"); } // overriding

    void run(int speed) { System.out.println("Sub.run(" + speed + ")"); } // overloading
}

Base b = new Sub();
b.run();     // Sub.run — override (runtime dispatch)
// b.run(10); // compile error — Base doesn't have run(int)

Schémas courants de surcharge

Utilisation courante de la surcharge dans les interfaces de programmation : fournir des méthodes pratiques qui délèguent à une version acceptant tous les paramètres.

class Connection {
    void connect(String host, int port, int timeout) {
        System.out.println("Connecting to " + host + ":" + port + " timeout=" + timeout);
    }

    // Convenience overloads
    void connect(String host, int port) {
        connect(host, port, 30); // delegate with default timeout
    }

    void connect(String host) {
        connect(host, 5432); // delegate with default port
    }
}

new Connection().connect("db.example.com");
// Connecting to db.example.com:5432 timeout=30

Surcharge et types génériques

La surcharge de méthodes génériques exige de la prudence : l'effacement des types peut rendre identiques après compilation deux signatures apparemment différentes.

// Type erasure problem: both methods erase to the same signature!
// static void process(List<String> list) {} // compile error
// static void process(List<Integer> list) {} // duplicate after erasure

// Solutions:
// 1. Use different method names: processStrings / processIntegers
// 2. Use a generic method with bounded type:
static <T extends Number> void processNumbers(List<T> list) {
    list.forEach(n -> System.out.println(n.doubleValue()));
}
processNumbers(List.of(1, 2, 3));
processNumbers(List.of(1.5, 2.5));

Cas pratique : surcharges de style générateur

La surcharge est courante dans les interfaces de construction ou de fabrique afin de proposer une création d'objets flexible.

class Notification {
    final String title, body;
    final String imageUrl;
    final boolean urgent;

    // Factory overloads for convenience
    static Notification simple(String title, String body) {
        return new Notification(title, body, null, false);
    }
    static Notification urgent(String title, String body) {
        return new Notification(title, body, null, true);
    }
    static Notification withImage(String title, String body, String url) {
        return new Notification(title, body, url, false);
    }
    Notification(String title, String body, String imageUrl, boolean urgent) {
        this.title = title; this.body = body;
        this.imageUrl = imageUrl; this.urgent = urgent;
    }
}

Pièges de la surcharge

Évitez ces erreurs courantes de surcharge :

  • Trop de surcharges pour une même opération : utilisez plutôt un générateur
  • Des surcharges qui diffèrent uniquement par l'ordre des paramètres : elles sont déroutantes
  • Un élargissement surprenant : un entier primitif peut être résolu vers un type long plutôt que vers un entier enveloppé
// Confusing: order-based overloads
// void save(String name, int age)  {}
// void save(int age, String name)  {} // very confusing!

// Better: use a record/DTO
record UserData(String name, int age) {}
void save(UserData data) {}

// Surprising widening
static void m(long x)   { System.out.println("long"); }
static void m(Integer x){ System.out.println("Integer"); }
int v = 5;
m(v); // long! widening preferred over autoboxing

Vérification rapide

Si une méthode est surchargée avec des paramètres long et Integer, lequel est choisi lors du passage d'un argument int ?

Récapitulatif : règles de surcharge des méthodes

Points essentiels :

  • La surcharge se distingue par le nombre, le type ou l'ordre des paramètres — pas uniquement par le type de retour
  • Java résout les surcharges à la compilation en utilisant le type déclaré des arguments
  • L'élargissement d'un type primitif est préféré à sa conversion automatique en type enveloppe
  • Les arguments nuls peuvent provoquer une ambiguïté — utilisez une conversion explicite pour la résoudre : handle((String) null)
  • La surcharge a lieu à la compilation, tandis que la redéfinition a lieu à l'exécution : ce sont deux mécanismes différents
  • Utilisez des surcharges pratiques qui délèguent à une méthode principale acceptant tous les paramètres

Questions Fréquemment Posées

La leçon « Règles de surcharge des méthodes » est-elle gratuite ?

Oui — le texte complet de « Règles de surcharge des méthodes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Règles de surcharge des méthodes » ?

Comprenez comment Java résout les méthodes surchargées et les pièges courants liés à l’ambiguïté. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Règles de surcharge des méthodes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Règles de surcharge des méthodes
  2. Paramètres varargs
  3. Champs statiques et constantes
  4. Classes utilitaires et méthodes de fabrique statiques
← Retour à Java Academy