Surcharge de méthode en Java avec des exemples

La surcharge de méthode a lieu lorsqu'une classe a plusieurs méthodes avec le même nom mais des paramètres différents. Si nous n'avons besoin de faire qu'une seule opération, avoir des méthodes nommées de la même manière améliore la lisibilité du programme. Si vous définissez la méthode comme a(int, int) pour deux paramètres et b(int, int, int) pour trois paramètres, il peut être difficile pour vous et les autres programmeurs de saisir le comportement. En conséquence, nous utilisons la surcharge pour comprendre le programme rapidement.

Quel est le but de la surcharge de méthode ?

Supposons que vous deviez exécuter l'addition des nombres fournis, mais il peut y avoir un nombre quelconque d'arguments (pour simplifier, considérons deux ou trois).

Créez deux méthodes, sum2num(int, int) et sum3num(int, int, int), pour deux et trois paramètres, respectivement, pour terminer le travail. D'autres programmeurs, ainsi que vous à l'avenir, peuvent être perplexes car l'action des deux méthodes est identique, mais leurs noms sont différents.

Les méthodes de surcharge sont un meilleur moyen d'accomplir cette tâche. En conséquence, l'une des méthodes surchargées est alors appelée, en fonction de l'argument donné. Ce dernier contribue à la lisibilité du programme.

Quel est l'avantage de la surcharge de méthodes en Java ?

La surcharge de méthodes présente plusieurs avantages. Certains d'entre eux incluent :

• Nous n'avons pas à développer de nouveaux noms pour les fonctions qui font la même chose. Si Java ne proposait pas de surcharger, il faudrait générer des noms de méthodes comme sum1, sum2,… ou sum2Int, sum3Int,… etc., dans notre code.
• La lisibilité du programme est améliorée par la surcharge des méthodes.
• Cela donne plus de liberté aux programmeurs, car ils peuvent utiliser la même approche pour différents types de données.
• La surcharge donne au code une apparence soignée.
• Le temps d'exécution est réduit car la liaison est effectuée pendant le processus de compilation.
• La surcharge des méthodes réduit la complexité du code.
• Cela nous permet de réutiliser le code, ce qui économise de la mémoire.

Comment le compilateur Java fait-il la distinction entre les méthodes surchargées ?

Le compilateur Java utilise les signatures des méthodes surchargées pour les distinguer. La signature d'une méthode comprend son nom et une liste de paramètres. La signature de la méthode n'inclut pas le type de retour de la méthode. Cela n'a aucune incidence sur la résolution des méthodes surchargées.

Lorsqu'une classe contient de nombreuses méthodes portant le même nom mais des listes de paramètres différentes, le compilateur les distingue en regardant le nombre de paramètres ou les types de paramètres fournis. Par conséquent, utilisez la surcharge de méthode avec prudence car le compilateur Java ne tient pas compte du type de retour lors de la différenciation des méthodes surchargées.

Qui (compilateur Java ou JVM) décide de la méthode surchargée à appeler ?

Étant donné que les méthodes sont appelées à l'aide d'objets, seule la JVM sélectionne la méthode surchargée à exécuter au moment de l'exécution (de manière dynamique). La JVM gère la construction d'un objet à l'exécution. Par conséquent, la JVM détermine quelle méthode surchargée est appelée lors de l'exécution. Au moment de la compilation, le compilateur Java ne décide pas laquelle des méthodes surchargées est appelée par l'utilisateur.

Comment la JVM sait-elle laquelle des méthodes surchargées est appelée ?

Lorsque plusieurs méthodes portant le même nom sont définies dans une classe, la JVM regarde la signature des méthodes. Le nom de la méthode et ses paramètres constituent la signature de la méthode.

Les signatures de deux méthodes portant le même nom seront presque certainement différentes. Deux personnes portant le même nom, par exemple, auront presque certainement des signatures différentes. JVM reconnaît que les deux méthodes sont distinctes en fonction de leurs signatures et détermine quelle méthode doit être invoquée.

Caractéristiques de surcharge de la méthode

Voici quelques-unes des fonctionnalités de surcharge de méthode en Java que vous devez connaître.

• L'appel à la méthode surchargée est lié au moment de la compilation.
• En Java, la surcharge de méthode est souvent appelée polymorphisme au moment de la compilation.
• Les méthodes de surcharge sont généralement effectuées dans la même classe. Cependant, nous pouvons également le faire dans la sous-classe. Vous devez utiliser le mot clé extend pour créer une relation entre les classes parent et enfant.
• En Java, la surcharge de méthode ne peut pas être accomplie en modifiant le type de retour de la méthode car cela peut générer une ambiguïté. D'autre part, les méthodes surchargées peuvent modifier le type de retour.
• En Java, nous pouvons surcharger les méthodes privées.
• En Java, les méthodes finales peuvent être surchargées.
• En Java, la méthode primaire peut également être surchargée.
• En Java, les méthodes statiques et d'instance peuvent être surchargées. Lorsque deux ou plusieurs méthodes statiques ont le même nom mais diffèrent dans la liste des paramètres, la surcharge de méthode est possible.

Quand devez-vous utiliser la méthode Java de surcharge ?

Bien que la surcharge de méthodes soit une fonctionnalité précieuse de Java, vous ne devez l'utiliser que lorsque cela est nécessaire. Il doit être utilisé lorsque de nombreuses méthodes avec des arguments distincts sont requises, mais qu'elles effectuent la même tâche. N'utilisez pas l'idée de surcharge de méthode si de nombreuses méthodes effectuent des tâches différentes. En Java, la surcharge de méthode est utilisée pour répondre aux exigences suivantes :

• Pour réutiliser le même nom de méthode, la surcharge de méthode est utilisée.
• Il est fait pour améliorer la lisibilité et la compréhension logiques du programme.
• Il est utilisé en Java pour obtenir un polymorphisme au moment de la compilation.

La surcharge peut se faire de plusieurs manières.

• Modification du nombre d'arguments
• Le type de données peut être modifié.
• La séquence du type de données des paramètres utilisés

La surcharge de méthode n'est pas possible en Java en modifiant simplement le type de retour de la méthode.

surcharge de méthode :modification du nombre d'arguments dans une méthode

Dans cet exemple, nous avons construit deux méthodes :la première fonction sumValues() ajoute deux entiers, tandis que la seconde méthode add() ajoute trois nombres. Nous construisons des méthodes statiques dans cet exemple afin de ne pas avoir à générer d'instances lors de l'appel de méthodes.

class Calculation{  
  static int sumValues(int a,int b){return a+b;}  
  static int sumValues(int a,int b,int c){return a+b+c;}  
}  
class OverloadingTestClass{  
  public static void main(String[] args){  
    System.out.println(Calculation.sumValues (14,52));  
    System.out.println(Calculation.sumValues (09,32, 45));  
  }
}  

Surcharger une méthode :modifier le type de données des arguments

Nous avons généré deux méthodes dans cet exemple, chacune avec un type de données différent. Deux arguments entiers sont passés à la première méthode d'ajout et deux arguments doubles sont donnés à la deuxième méthode d'ajout.

class Calculation{  
  static int sumValues(int a, int b){return a+b;}  
  static double sumValues(double a, double b){return a+b;}  
}  
class TestOverloading2{  
  public static void main(String[] args){  
    System.out.println(Calculation .sumValues (33,61));  
    System.out.println(Calculation .sumValues (67.55,48.65));  
  }
}  

Surcharge de méthode :la séquence des paramètres de type de données

Par exemple :

sumValues(int, float)
  
sumValues(float, int)

La fonction dispValues() est surchargée en fonction de la séquence des types de données des paramètres - la séquence des types de données dans la liste d'arguments est différente dans les deux méthodes. La première technique utilise une liste d'arguments (char, int), tandis que la seconde approche utilise une liste d'arguments (char, int) (int, char). La méthode peut être surchargée sans problème car la séquence est différente.

class OverloadingClass
{
   public void dispValues(char c, int num)
   {
       System.out.println("I'm the first definition of method disp");
   }
   public void dispValues(int num, char c)
   {
       System.out.println("I'm the second definition of method disp" );
   }
}
class OverloadingTestClass
{
   public static void main(String args[])
   {
       OverloadingClass overloadClass = new OverloadingClass();
       overloadClass.dispValues ('x', 21 );
       overloadClass.dispValues (62, 'y');
   }
}

Promotion de type et surcharge de méthode

Un type est implicitement promu à un autre si aucun type de données correspondant n'est identifié. Regardons une illustration pour mieux comprendre le concept. Un octet peut être promu en short, int, long, float ou double. Les types de données int, long, float ou double peuvent tous être promus à partir du type de données short. Le type de données char peut être promu à d'autres types de données tels que int, long, float et double. TypePromotion est un exemple de surcharge de méthode.

class Calculation{  
  void sumValues(int a,long b){System.out.println(a+b);}  
  void sumValues(int a,int b,int c){System.out.println(a+b+c);}  

  public static void main(String args[]){  
    Calculation calcObj=new Calculation();  
    calcObj.sumValues (45,40);//now second int literal will be promoted to long  
    calcObj.sumValues (45,40,45);  

  }  
}  

Exemple :Surcharge de méthode avec promotion de type si correspondance trouvée

La promotion de type n'est pas appliquée si la méthode a des arguments de type correspondants.

class Calculation{  
  void sumValues(int a,int b){System.out.println("int arg method invoked");}  
  void sumValues(long a,long b){System.out.println("long arg method invoked");}  

  public static void main(String args[]){  
    Calculation obj=new Calculation();  
    obj.sumValues (45,45);//now int arg sum() method gets invoked  
  }  
}  

Exemple :Surcharge de méthode avec promotion de type en cas d'ambiguïté

En cas d'ambiguïté, un exemple de surcharge de méthode avec promotion de type. Il y aura ambiguïté si la méthode n'a pas d'arguments de type correspondant et que chaque méthode promeut une quantité comparable de paramètres.

class Calculation{  
  void sumValues(int a,long b){System.out.println("a method invoked");}  
  void sumValues(long a,int b){System.out.println("b method invoked");}  

  public static void main(String args[]){  
    Calculation calc=new Calculation();  
    calc.sumValues(45,45);//now ambiguity  
  }  
}  

Foire aux questions

Voici les questions fréquentes sur la surcharge de méthode.

Est-il possible de surcharger la fonction main() en Java ?

Surcharge de méthode, pour être précis. La surcharge de méthodes vous permet d'avoir n'importe quel nombre de méthodes principales dans une classe. Cependant, JVM invoque la fonction main(), qui n'accepte qu'un tableau de chaînes comme argument. Prenons un exemple simple :

class OverloadingTestClass{  
  public static void main(String[] args){System.out.println("main with String[]");}  
  public static void main(String args){System.out.println("main with String");}  
  public static void main(){System.out.println("main without args");}  
}  

Exemple :un programme Java avec un main() surchargé

import java.io.*;

public class OverloadClass {

	// Normal main()
	public static void main(String[] args)
	{
		System.out.println("Hi Code (from main)");
		OverloadClass.main("Code");
	}

	// Overloaded main methods
	public static void main(String arg1)
	{
		System.out.println("Hi, " + arg1);
		OverloadClass.main("Dear Code", "My Code");
	}
	public static void main(String arg1, String arg2)
	{
		System.out.println("Hi, " + arg1 + ", " + arg2);
	}
}

Pourquoi la surcharge de méthode n'est-elle pas disponible uniquement en modifiant le type de retour de la méthode ?

En raison de l'ambiguïté, la surcharge de méthode en Java n'est pas réalisable en modifiant le type de retour de la méthode. Examinons quelques exemples d'ambiguïté :

class Calculation{  
  static int sumValues(int a,int b){return a+b;}  
  static double sumValues(int a,int b){return a+b;}  
}  
class OverloadingTestClass{  
  public static void main(String[] args){  
    System.out.println(Calculation.sumValues (45,45));//ambiguity  
  }
}  


System.out.println(Calculation.sumValues(45,45)); // How does Java know which sumValues() method to use in this case?

L'erreur de compilation est préférable à l'erreur d'exécution. Si vous déclarez la même méthode avec les mêmes paramètres, le compilateur java génère une erreur.

Est-il possible de surcharger les méthodes statiques ?

"Oui", est la réponse. Deux méthodes statiques ou plus portant le même nom mais des paramètres d'entrée différents sont possibles. Prenez, par exemple, l'application Java ci-dessous. Pour plus d'informations, consultez ceci.

// filename Test.java
public class OverloadClass {

	public static void showInfo() {
		System.out.println("Test.foo() called ");
	}
	public static void showInfo(int a) {
		System.out.println("OverloadClass.showInfo (int) called ");
	}
	public static void main(String args[])
	{
		OverloadClass.showInfo ();
		OverloadClass.showInfo (10);
	}
}

Est-il possible de surcharger des méthodes qui ne diffèrent que par le mot-clé static ?

En Java, on ne peut pas surcharger deux méthodes qui ne diffèrent que par le mot clé static (le nombre de paramètres et les types de paramètres sont les mêmes). Par exemple, regardez l'application Java ci-dessous. Pour plus d'informations, consultez ceci.

// filename Test.java
public class OverloadClass {

	public static void showInfo() {
		System.out.println("OverloadClass.showInfo () called ");
	}
	public void showInfo() { // Compiler Error: cannot redefine showInfo()
		System.out.println("OverloadClass.showInfo (int) called ");
	}
	public static void main(String args[]) {
		OverloadClass.showInfo ();
	}
}

La surcharge d'opérateur est-elle prise en charge en Java ?

Java ne prend pas en charge les opérateurs surchargés définis par l'utilisateur, contrairement à C++. Java surcharge les opérateurs en interne ; par exemple, l'opérateur + est surchargé pour la concaténation.

Surcharge vs écrasement :quelle est la différence ?

La surcharge fait référence à l'utilisation de différentes signatures pour une même fonction. D'autre part, le remplacement se produit lorsque deux classes ou plus partagent la même fonction et la même signature mais sont liées par héritage.

Exemple 1 : Surcharge – Les types de données de paramètre diffèrent

La méthode disp() est surchargée dans cet exemple en fonction du type de données des paramètres - nous avons deux méthodes avec le nom disp(), l'une avec un paramètre de type char et l'autre avec un paramètre de type int.

class OverloadingClass
{
    public void dispValues(char c)
    {
        System.out.println(c);
    }
    public void dispValues(int c)
    {
       System.out.println(c );
    }
}

class OverloadingTestClass
{
    public static void main(String args[])
    {
        OverloadingClass overloadClass = new OverloadingClass();
        overloadClass.dispValues ('a');
        overloadClass.dispValues (5);
    }
}

Exemple 2 : Surcharge – Nombre de paramètres différent dans la liste d'arguments

Cet exemple montre comment la surcharge de méthode est accomplie en faisant varier le nombre de paramètres.

class OverloadingClass
{
    public void dispValues(char c)
    {
         System.out.println(c);
    }
    public void dispValues(char c, int num)  
    {
         System.out.println(c + " "+num);
    }
}
class OverloadingTestClass
{
   public static void main(String args[])
   {
       OverloadingClass overloadClass = new OverloadingClass();
       overloadClass.dispValues ('a');
       overloadClass.dispValues('a',10);
   }
}

Exemple 3 :Surcharge de méthode et promotion de type

class OverloadingClass{

   void dispValues(int a, double b){
	System.out.println("Approach I");
   }
  
   void dispValues(int a, double b, double c){
	System.out.println("Approach II");	
   }
  
   public static void main(String args[]){
	OverloadingClass overloadClass = new OverloadingClass();
	/*
	* I'm sending a float value as a second argument,
	* but it was promoted to the type double because
	* no method had an arg list like (int, float)
	*/

	overloadClass.dispValues (350, 55.75f);
   }
}

Exemple :Exemple concret de surcharge de méthode

class CodeHelperService {

    private String formatNumber(int value) {
        return String.format("%d", value);
    }

    private String formatNumber(double value) {
        return String.format("%.3f", value);
    }

    private String formatNumber(String value) {
        return String.format("%.2f", Double.parseDouble(value));
    }

    public static void main(String[] args) {
        CodeHelperService codeService = new CodeHelperService();
        System.out.println(codeService .formatNumber(324));
        System.out.println(codeService .formatNumber(78.9934));
        System.out.println(codeService .formatNumber("128"));
    }
}

Conclusion

La surcharge de méthode est une fonctionnalité qui permet à une classe d'avoir plusieurs méthodes avec le même nom mais des listes d'arguments différentes. C'est analogue à la surcharge de constructeur de Java, qui permet à une classe d'avoir de nombreux constructeurs avec différentes listes d'arguments.

Revenons à l'essentiel :quand on dit liste d'arguments, on fait référence aux paramètres d'une méthode. C'est-à-dire que la liste d'arguments d'une méthode sumValues(int a, int b) avec deux arguments diffère de la liste d'arguments d'une méthode sumValues(int a, int b, int c) avec trois paramètres.

Si nous modifions simplement le type de retour des méthodes, il ne s'agit pas d'une surcharge de méthode. Des différences dans le nombre de paramètres doivent exister.

Certaines choses à garder à l'esprit lorsqu'il s'agit de surcharge de méthode incluent la modification du type de retour des méthodes qui ne permet pas la surcharge de méthode. De plus, la règle la plus fondamentale de la surcharge de méthode est que les arguments de deux méthodes surchargées doivent différer.