Surcharge Java | Surcharge de méthode | Exemples

Java

Surcharge Java définit deux ou plusieurs méthodes portant le même nom. Mais Surcharge de méthode en Java a le même nom avec un nombre différent de paramètres, différents types de paramètres, ou les deux.

La surcharge de méthodes relève du concept Polymorphism OOPs. Et c'est aussi appelé polymorphisme au moment de la compilation (ou statique).

Syntaxe

La syntaxe de modification du nombre d'arguments/paramètres dans la surcharge de méthode.

int add_method(int, int)
int add_method(int, int, int)

Méthode Java surchargeant la syntaxe en modifiant les types de données.

Différentes façons de surcharger la méthode

Modification du nombre d'arguments/paramètres
Modifier le type de données

Remarque :Pour obtenir des méthodes, la surcharge en Java peut également être effectuée en modifiant à la fois les paramètres et les types de données.

Exemple de surcharge de méthode Java

Lorsque nous parlons de Java Overdoing, cela signifie une surcharge de méthode en Java. Ici, nous écrivons un programme d'exemple de surcharge de méthode java.

Surcharge de méthode avec changement d'arguments

Créons des méthodes d'addition de nombres (valeur entière), il y aura 2 méthodes portant le même nom. L'un ajoutera 2 numéros et un autre ajoutera 3 numéros. Ainsi, la transmission de données avec différents nombres d'arguments est automatiquement détectée par le compilateur Java.

Par exemple, définir une méthode statique parce que la méthode principale est statique et ne peut pas accéder aux méthodes non statiques.

public class MethodOverloading {
    static int add(int a, int b) {
        return a + b;
    }

    static int add(int a, int b, int c) {
        return a + b + c;
    }
    public static void main(String[] args) {
        System.out.println(MethodOverloading.add(2, 16));
        System.out.println(MethodOverloading.add(78, 1, 9));
    }
}

Sortie : 18
88

Surcharge de méthode :modification du type de données des arguments

L'exemple ci-dessus était uniquement basé sur la modification du nombre d'arguments (paramètres), voyons maintenant comment effectuer une surcharge dans les méthodes en modifiant un type de données en Java.

Dans l'exemple, nous devons 2 méthodes, la première est avec un nombre entier et la seconde est pour les méthodes d'ajout de nombres doubles.

public class MethodOverloading {
    static int add(int a, int b) {
        return a + b;
    }

    static double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(MethodOverloading.add(2, 16));
        System.out.println(MethodOverloading.add(78.9, 1.9));
    }
}

Sortie : 18

80.80000000000001

Surcharge du constructeur

Vous pouvez effectuer une surcharge de constructeur en Java, de la même manière que celle utilisée dans la surcharge de méthodes. Le constructeur surchargé est appelé ou sélectionné en fonction de la création d'un objet utilisé le nouveau mot-clé spécifié.

Voir ci-dessous Exemple de surcharge de constructeur.

public class ConstructorOverloading {

    //default Constructor
    public ConstructorOverloading() {
        System.out.println("Default Constructor");
    }

    //Constructor Overloading
    public ConstructorOverloading(String r) {
        System.out.println(r);
    }

    //Constructor Overloading
    public ConstructorOverloading(int r1, int r2) {
        System.out.println(r1 + r2);
    }

    public static void main(String arg[]) {
        ConstructorOverloading co = new ConstructorOverloading();

        ConstructorOverloading co1 = new ConstructorOverloading("Constructor Overloading");

        ConstructorOverloading co2 = new ConstructorOverloading(1, 6);
    }
}

Sortie : Constructeur par défaut
Surcharge du constructeur
7

Opérateurs de surcharge Java

Java n'autorise pas la surcharge des opérateurs. L'approche préférée consiste à définir une méthode dans votre classe pour effectuer l'action :a.add(b) au lieu de a + b .

Vérifier les règles de surcharge des méthodes en Java :

Tous les noms de méthode doivent être identiques.
En cas de surcharge des arguments/paramètres, les paramètres doivent être différents.
Ce n'est qu'avec différents types de retour de méthodes que les méthodes ne peuvent pas être surchargées.

Q :Pourquoi la surcharge de méthode n'est-elle pas possible en modifiant uniquement la méthode du type de retour ?

Réponses : Seule la modification d'un type de données de retour dans la surcharge de méthode Java n'est pas possible en raison de l'ambiguïté des données.

Essayons un exemple de surcharge avec le même nom de méthode, les mêmes arguments mais différents types de retour. Il affichera certainement une erreur de temps de compilation.

public class MethodOverloading {
    static int add(int a, int b) {
        return a + b;
    }

    static double add(int a, int b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(MethodOverloading.add(2, 16));
        System.out.println(MethodOverloading.add(78, 1));
    }
}

Capture d'écran de l'erreur : Error:(6, 19) java: la méthode add(int,int) est déjà définie dans la classe MethodOverloading

Q :Pouvons-nous surcharger la méthode main() de Java ? [Question très importante)

Réponses :Oui, il est possible de surcharger les méthodes Java Main() autant de fois que vous le souhaitez.

Maintenant, quelle méthode principale appellera ?

JVM n'appellera qu'une méthode main() qui a un tableau de chaînes comme arguments uniquement. Regardez l'exemple ci-dessous.

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

    public static void main(String args) {
        System.out.println("Overloading main with String");
    }

    public static void main() {
        System.out.println("Overloading main without args");
    }
}

Sortie : principal avec String[] Array

Q :Pourquoi la surcharge de méthode ?

Réponses : Quelques utilisations et avantages de la surcharge des méthodes en java. Facile à retenir - Pas besoin de créer plusieurs méthodes différentes pour effectuer la même opération.

Ou, dans ce cas, si vos méthodes sont mises à jour pour une nouvelle application, cette fois-ci, vous pouvez la créer avec le même nom. Les anciennes méthodes prennent en charge une ancienne version de l'application et une nouvelle pour une nouvelle application sous le même nom. (Version Méthodes)

Remarque : En raison de la surcharge utilisée sur les méthodes, c'est pourquoi on l'appelle également surcharge de méthode en Java.