Surcharge de fonctions en Java

La surcharge de fonctions en Java se produit lorsqu'il y a des fonctions portant le même nom mais auxquelles sont transmis des nombres différents de paramètres, qui peuvent être différents dans les données comme int, double, float et utilisés pour renvoyer différentes valeurs sont calculées à l'intérieur de la surcharge respective. méthode. La surcharge de fonctions est utilisée pour réduire la complexité et augmenter l'efficacité du programme en impliquant davantage de fonctions séparées et pouvant être utilisées pour se distinguer en fonction de leurs fonctionnalités individuelles. Les fonctions surchargées sont liées au polymorphisme au moment de la compilation ou au polymorphisme statique. Il existe également un concept de conversion de type, qui est essentiellement utilisé dans les fonctions surchargées utilisées pour calculer la conversion de type en variables.

Syntaxe

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Les fonctions surchargées ont le même nom mais différents types d'arguments ou de paramètres leur sont attribués. Ils peuvent être utilisés pour calculer des opérations mathématiques ou logiques dans la limite du nombre de variables attribuées dans la méthode. La syntaxe de la fonction surchargée peut être donnée ci-dessous, où jusqu'à N nombre de variables sont attribuées.

public class OverloadedMethod
{
public int FunctionName(int x, int y) //Two parameters in the function
{
return (x + y); //Returns the sum of the two numbers
}
// This function takes three integer parameters
public int FunctionName(int x, int y, int z)
{
return (x + y + z);
}
// This function takes two double parameters
public double FunctionName(double x, double y)
{
return (x + y);
}//Many more such methods can be done with different number of parameters
// Code used to input the number and
public static void main(String args[])
{
FunctionName s = new FunctionName();
System.out.println(s.FunctionName(10, 20));
System.out.println(s. FunctionName(10, 20, 30));
System.out.println(s. FunctionName(10.5, 20.5));
}
}

Fonctionnement de la surcharge de fonctions

La surcharge de fonctions fonctionne en appelant différentes fonctions ayant le même nom, mais le nombre différent d'arguments qui lui sont transmis. Il existe de nombreux exemples de codage qui peuvent être présentés afin d'identifier correctement les avantages et les inconvénients de la surcharge de fonctions.

Avantage de la surcharge de fonctions

La surcharge de fonctions fonctionne avec le même nom. Nous n’avons donc pas besoin de créer des méthodes qui ont la même chose que le travail effectué dans une fonction respective. La fonctionnalité résout non seulement le problème des noms conflictuels, mais améliore également la lisibilité du programme.

Exemples de surcharge de fonctions

Les exemples suivants sont donnés ci-dessous :

Exemple n°1

Dans l'exemple de codage 1, nous verrons la fonction main() surchargée, qui est utilisée pour afficher différentes sorties dans le panneau et montrer comment la fonction main() surchargée est utilisée dans les langages de programmation et comment l'appel des différentes fonctions produit différentes sorties. , respectivement.

Code :

//Java program with overloaded main()
import java.io.*;
public class Test
{
// First main method which is created
public static void main(String[] args)
{
System.out.println("Main function called");
Test.main("Everyone");
}
// First overloaded main method
public static void main(String ar1)
{
System.out.println("Hi, " + ar1);
Test.main("Hello Everyone", "Buenos dias");
}
//Second overloaded main method
public static void main(String ar1, String ar2)
{
System.out.println("Mi todo eres tu, " + ar1 + ", " + ar2);
}
}

Lorsque main() est appelé, une sortie est affichée de manière significative dans le panneau de sortie, comme indiqué ci-dessous. Tout d’abord, l’instruction print de main() est appelée et imprimée. Puis, en distinguant le nombre d'arguments, le programme sépare les deux fonctions surchargées qui sont présentes dans le morceau de code. Le main() appelle la première fonction surchargée, tandis que la première fonction surchargée appelle la deuxième fonction surchargée.

Sortie :

Exemple n°2

Dans le deuxième exemple de codage, nous allons voir des fonctions qui effectueront une multiplication mais qui se verront attribuer un nombre d'arguments différent. Cela aidera les gens à développer les différentes fonctions destinées à traiter différents arguments.

Code :

class Adder
{
static int multiply(int a,int b)
{
return a*b;
}
static int multiply(int a,int b,int c)
{
return a*b*c;}
}
class TestOverloading1
{
public static void main(String[] args)
{
System.out.println(Adder.multiply(110,110));
System.out.println(Adder.multiply(110,110,110));
}
}

Sortie :

Exemple #3

Dans cet exemple de codage, nous allons voir des fonctions qui ont le même nom et le même nombre d'arguments à l'intérieur, mais elles ont une fonctionnalité qui fait la différence entre elles. La différence de fonctionnalité présente est le type de données présent dans les fonctions, l'un est un entier et l'autre est double.

Code :

//Program to add numbers distinguishing on the datatype of parameters
class Number
{
static int add(int a, int b)//Both integer variables
{
return a+b;//Returning the sum
}
static double add(double a, double b)//Both double variables
{
return a+b;//Returning the sum
}
}
class TestOverloading2
{
public static void main(String[] args)
{
System.out.println(Number.add(1,110));
System.out.println(Number.add(12.4,18.8));
}
}

Dans le programme ci-dessus, nous saisissons deux valeurs entières lorsque nous calculons la somme de deux valeurs entières. Les nombres saisis sont 10 et 20. La sortie devrait nous donner la valeur 30, ce qui imprimerait la somme telle quelle. De plus, lorsque nous saisissons deux valeurs doubles, la somme est imprimée, ce qui constitue la deuxième fonction surchargée. Nous entrons les valeurs des variables de type de données doubles comme 15,5 et 16,3, puis nous obtenons finalement le résultat comme 31,8, qui est la somme. Nous verrons le panneau de sortie du programme dans l'écran ci-dessous.

Sortie :

Conclusion

Dans cet article, nous voyons les différentes fonctionnalités et concepts des fonctions surchargées, qui portent le même nom, mais le nombre d'arguments ou les types de données sont différents. Nous remarquons également les avantages et la syntaxe quant à la manière dont les fonctions surchargées doivent être exécutées. Dans cet article, les fonctions surchargées sont principalement utilisées pour multiplier et faire des additions, ce qui donne beaucoup de détails à l'ensemble du concept de programmation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!