Bases de la surcharge de méthodes

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 28 sur 87.

Le polymorphisme signifie « plusieurs formes ». En Java, il permet aux objets de se comporter différemment selon le contexte. Une forme de polymorphisme est la surcharge de méthode (method overloading), également appelée polymorphisme de compilation, car Java détermine quelle méthode appeler pendant la compilation.

La surcharge de méthodes vous permet de définir plusieurs méthodes portant le même nom mais ayant des paramètres différents. Le compilateur les distingue en fonction du nombre, du type ou de l'ordre des paramètres :

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

Lorsque vous appelez add(5, 3), Java utilise la première méthode. Appeler add(5, 3, 2) déclenche la deuxième, et add(5.0, 3.0) invoque la troisième. Le compilateur choisit la bonne version en fonction des arguments que vous fournissez.

Notez que modifier uniquement le type de retour n'est pas une surcharge valide. La liste des paramètres doit différer :

// Surcharge NON valide - ne compilera pas
public int getValue() { return 1; }
public double getValue() { return 1.0; }  // Erreur !

Vous avez déjà rencontré la surcharge auparavant avec la surcharge de constructeur. La surcharge de méthode suit les mêmes règles et offre de la flexibilité en permettant à un seul nom de méthode de gérer différents scénarios d'entrée.

Défi

Facile

Construisons un formateur de messages qui illustre la surcharge de méthodes en proposant plusieurs façons de formater des messages. Vous allez créer une classe utilitaire avec plusieurs méthodes format surchargées qui gèrent différents scénarios d'entrée.

Vous organiserez votre code sur deux fichiers :

MessageFormatter.java : Créez une classe qui offre un formatage de message flexible grâce à des méthodes surchargées. Votre formateur doit avoir :
- Une méthode format(String message) qui renvoie le message entouré de crochets : [message]
- Une méthode format(String message, int repeatCount) qui renvoie le message répété le nombre de fois spécifié, séparé par des espaces
- Une méthode format(String message, String prefix) qui renvoie le message avec le préfixe attaché : prefix: message
- Une méthode format(String message, String prefix, String suffix) qui renvoie : prefix: message (suffix)
Le compilateur choisira la bonne méthode en fonction des arguments que vous passez - c'est le polymorphisme au moment de la compilation en action !
Main.java : Démontrez le fonctionnement des quatre méthodes surchargées ensemble. Vous recevrez quatre entrées : un message (String), un nombre de répétitions (int), un préfixe (String) et un suffixe (String). Créez un MessageFormatter et appelez chaque version de la méthode format, en affichant chaque résultat sur sa propre ligne :
- Premièrement, formatez avec seulement le message
- Deuxièmement, formatez avec le message et le nombre de répétitions
- Troisièmement, formatez avec le message et le préfixe
- Quatrièmement, formatez avec le message, le préfixe et le suffixe

Vous recevrez quatre entrées : le texte du message, le nombre de fois qu'il doit être répété, une chaîne de préfixe et une chaîne de suffixe.

Par exemple, si le message est "Hello", le nombre de répétitions est 3, le préfixe est "INFO" et le suffixe est "done", votre sortie devrait afficher quatre versions formatées différentes du même message, chacune utilisant une méthode surchargée différente !

Aide-mémoire

La surcharge de méthodes vous permet de définir plusieurs méthodes avec le même nom mais des paramètres différents. On l'appelle aussi polymorphisme à la compilation car Java détermine quelle méthode appeler lors de la compilation.

Le compilateur distingue les méthodes surchargées en fonction du nombre, du type ou de l'ordre des paramètres :

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

Lors de l'appel de add(5, 3), Java utilise la première méthode. L'appel de add(5, 3, 2) déclenche la deuxième, et add(5.0, 3.0) invoque la troisième.

Important : Changer uniquement le type de retour n'est pas une surcharge valide. La liste des paramètres doit différer :

// Surcharge NON valide
public int getValue() { return 1; }
public double getValue() { return 1.0; }  // Erreur !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String message = scanner.nextLine();
        int repeatCount = Integer.parseInt(scanner.nextLine());
        String prefix = scanner.nextLine();
        String suffix = scanner.nextLine();
        
        // TODO: Créer un objet MessageFormatter
        
        // TODO: Appeler format avec seulement le message et afficher le résultat
        
        // TODO: Appeler format avec message et repeatCount et afficher le résultat
        
        // TODO: Appeler format avec message et prefix et afficher le résultat
        
        // TODO: Appeler format avec message, prefix, et suffix et afficher le résultat
        
    }
}