Surcharge d'opérateur en Java

1. Surcharge d’opérateur en Java
2. Raisons pour lesquelles Java ne prend pas en charge la surcharge d’opérateur
3. Conclusion

Cet article explique si Java prend en charge ou non la surcharge des opérateurs définis par l’utilisateur.

Surcharge d’opérateur en Java

La surcharge d’opérateurs est la manière dont les opérateurs peuvent être implémentés dans des types définis par l’utilisateur. Il utilise une logique personnalisée basée sur le type et le nombre d’arguments que nous passons.

En utilisant la surcharge d’opérateur, nous pouvons spécifier l’implémentation d’une opération définie par l’utilisateur. Le sucre syntaxique est un autre terme pour cela. Les opérateurs impliqués dans l’opération peuvent être de type structure ou de classe définie par l’utilisateur.

Par exemple, l’utilisation d’un opérateur plus + pour additionner deux nombres et concaténer deux chaînes est le cas le plus simple de surcharge d’opérateur.

Cependant, Java ne prend pas en charge la surcharge d’opérateurs, sauf dans un cas, la concaténation de chaînes à l’aide de l’opérateur plus.

Voici l’exemple complet.

import java.util.Scanner;
public class OperatorOverloading {
  public static void main(String args[]) {
    Scanner sc = new Scanner(System.in);

    // Input the first string
    System.out.println("Enter a string");
    String s1 = sc.next();

    // Input the second string
    System.out.println("Enter another string: ");
    String s2 = sc.next();

    // Plus operator concatenates the two Strings
    System.out.println(s1 + ' ' + s2);

    // Input the first integer
    System.out.println("Enter a number");
    int x = sc.nextInt();

    // Input the second integer
    System.out.println("Enter another number");
    int y = sc.nextInt();

    // Plus operator adds the two numbers
    System.out.println(x + y);
  }
}

Production :

Enter a string
Hello
Enter another string:
World
Hello World
Enter a number
3
Enter another number
4
7

Dans cet exemple, l’opérateur plus additionne les deux entiers et concatène les deux chaînes. C’est la seule surcharge d’opérateur prise en charge par Java.

En dehors de cela, Java ne prend pas en charge la surcharge d’opérateurs définis par l’utilisateur. La seule partie de Java proche de la surcharge d’opérateurs est la gestion du + pour la concaténation des chaînes.

Il en résulte la concaténation au moment de la compilation des constantes ou la concaténation au moment de l’exécution. Cependant, en Java, nous ne pouvons pas définir nos opérateurs, qui agissent comme ceci.

Bien que nous puissions concaténer des chaînes en Java à l’aide de l’opérateur plus, Java possède une méthode concat() intégrée qui élimine le besoin de surcharger l’opérateur. La méthode concat() ajoute une autre chaîne à la fin d’une chaîne donnée.

Nous devons spécifier les chaînes pour obtenir la chaîne combinée dans l’ordre souhaité.

Syntaxe:

String resultant = String1.concat(String2)

Il ajoutera la deuxième chaîne à la fin de la première chaîne. L’exemple ci-dessous utilise la méthode concat() pour assembler deux chaînes.

import java.util.Scanner;
public class OperatorOverloading {
  public static void main(String args[]) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter a string:");
    String s1 = sc.next();
    System.out.println("Enter another string:");
    String s2 = sc.next();

    // Concatenate the two strings using concat() method
    String res = s1.concat(s2);
    System.out.println(res);
  }
}

Production :

Enter a string:
Hello
Enter another string:
World
HelloWorld

Notez qu’ici, nous n’utilisons pas l’opérateur plus pour la concaténation de chaînes, et nous pouvons toujours combiner les deux chaînes à l’aide de la méthode concat().

Raisons pour lesquelles Java ne prend pas en charge la surcharge d’opérateur

Nous pouvons redéfinir la plupart des opérateurs intégrés en C++ mais pas en Java. Cela est dû aux raisons suivantes.

• La surcharge des opérateurs augmente la complexité du code. Si nous surchargeons un opérateur en Java, la machine virtuelle Java (JVM) en Java doit faire un effort supplémentaire pour découvrir la fonctionnalité réelle de l’opérateur utilisé dans une instruction particulière. Cela rend le traitement assez complexe.
• La surcharge de l’opérateur introduit des erreurs dans le programme. La surcharge des opérateurs crée de la confusion parmi les programmeurs. De plus, travailler avec des langages prenant en charge la surcharge d’opérateurs présente des risques d’erreur par rapport à d’autres langages. Java a une surcharge de méthode. La surcharge de méthode sert la fonctionnalité de surcharge de l’opérateur et élimine le risque d’erreurs.
• Java prend en charge la surcharge de méthode. La surcharge de méthode est le concept d’une classe ayant plus d’une seule méthode avec le même nom mais des paramètres différents. L’identification de la méthode à utiliser est ici plus facile. Cela dépend du nombre d’arguments ou du type de données des arguments.

Voyons un exemple.

import java.util.*;

// The class which has two methods
class DemoClass {
  // This method takes two arguments
  static int demo(int a, int b) {
    return a + b;
  }

  // This method takes three arguments
  static int demo(int a, int b, int c) {
    return a * b * c;
  }
}

class MethodOverloading {
  public static void main(String[] args) {
    // Passing two arguments
    System.out.println(DemoClass.demo(10, 12));

    // Passing three arguments
    System.out.println(DemoClass.demo(11, 10, 10));
  }
}

Production :

22
1100

La classe DemoClass a deux méthodes portant le même nom, demo, dans l’exemple ci-dessus. Mais ces deux méthodes prennent des nombres d’arguments différents.

Lorsque nous passons deux arguments, la première méthode de démonstration entre en action, et lorsque nous passons trois arguments, la seconde méthode de démonstration entre en action. C’est ainsi que fonctionne la surcharge de méthode en Java.

Pour garder le langage simple, les développeurs de Java n’ont pas fourni la fonctionnalité de surcharge des opérateurs. Chaque opérateur a une signification que nous pouvons modifier en fonction des besoins du développeur.

Cela crée de la confusion lorsque plusieurs personnes travaillent sur le même projet. Les concepteurs Java ont évité la surcharge d’opérateurs en Java pour éviter d’utiliser des opérateurs. Cela fait de Java un langage facile à implémenter.

Quelques langages de type Java, également connus sous le nom de langages basés sur JVM, prennent en charge la surcharge des opérateurs. Ceux-ci incluent Groovy et Kotlin.

Développé par Jetbrains, Kotlin est un langage de haut niveau à typage statique. Il s’exécute sur la machine virtuelle Java ou JVM et peut même être compilé en code source Javascript.

L’une des avancées majeures de Kotlin par rapport à Java est que Kotlin prend en charge la surcharge des opérateurs, contrairement à Java.

D’autre part, Groovy prend en charge le typage statique et dynamique et se compile en Java Virtual Machine ByteCode. Groovy prend également en charge la surcharge des opérateurs.

Conclusion

En réponse à la question de savoir si Java prend en charge ou non la surcharge d’opérateurs, Java ne prend pas en charge la surcharge d’opérateurs. Une seule partie de Java ressemble à ce concept : la concaténation de chaînes à l’aide de l’opérateur plus.

En dehors de cela, Java ne vous permet pas de définir vos opérateurs. Cependant, quelques autres langages basés sur JVM, comme Java, prennent en charge la surcharge des opérateurs.

Ceux-ci incluent Groovy et Kotlin. Mais ce ne sont pas les mêmes que Java.