Sobrecarga de operadores en Java

1. Sobrecarga de operadores en Java
2. Razones por las que Java no admite la sobrecarga de operadores
3. Conclusión

Este artículo analiza si Java admite o no la sobrecarga de operadores definida por el usuario.

Sobrecarga de operadores en Java

La sobrecarga de operadores es la forma en que se pueden implementar operadores en tipos definidos por el usuario. Utiliza una lógica personalizada basada en el tipo y la cantidad de argumentos que pasamos.

Usando la sobrecarga de operadores, podemos especificar la implementación de operaciones definidas por el usuario. El azúcar sintáctico es otro término para esto. Los operadores involucrados en la operación pueden ser de tipo estructura o clase definida por el usuario.

Por ejemplo, usar un operador más + para sumar dos números y concatenar dos cadenas es el caso más simple de sobrecarga de operadores.

Sin embargo, Java no admite la sobrecarga de operadores excepto en un caso, la concatenación de cadenas utilizando el operador más.

Aquí está el ejemplo completo.

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);
  }
}

Producción :

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

En este ejemplo, el operador más suma los dos enteros y concatena las dos cadenas. Es la única sobrecarga de operadores que admite Java.

Aparte de esto, Java no admite la sobrecarga de operadores definida por el usuario. La única parte de Java cercana a la sobrecarga de operadores es el manejo de + para concatenar cadenas.

Da como resultado la concatenación de constantes en tiempo de compilación o la concatenación en tiempo de ejecución. Sin embargo, en Java, no podemos definir nuestros operadores, que actúan así.

Aunque podemos concatenar cadenas en Java utilizando el operador más, Java tiene un método concat() integrado que elimina la necesidad de realizar una sobrecarga de operadores. El método concat() agrega otra cadena al final de una cadena dada.

Deberíamos especificar las cadenas para obtener la cadena combinada en el orden que deseamos.

Sintaxis:

String resultant = String1.concat(String2)

Agregará la segunda cadena al final de la primera cadena. El siguiente ejemplo usa el método concat() para juntar dos cadenas.

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);
  }
}

Producción :

Enter a string:
Hello
Enter another string:
World
HelloWorld

Tenga en cuenta que aquí no estamos usando el operador más para la concatenación de cadenas, y aún podemos combinar las dos cadenas con la ayuda del método concat().

Razones por las que Java no admite la sobrecarga de operadores

Podemos redefinir la mayoría de los operadores incorporados en C++ pero no en Java. Se debe a las siguientes razones.

• La sobrecarga de operadores aumenta la complejidad del código. Si sobrecargamos un operador en Java, la máquina virtual de Java (JVM) en Java debe hacer un esfuerzo adicional para descubrir la funcionalidad real del operador utilizado en cualquier declaración en particular. Hace que el procesamiento sea bastante complejo.
• La sobrecarga de operadores introduce errores en el programa. La sobrecarga de operadores crea confusión entre los programadores. Además, trabajar con lenguajes que admiten la sobrecarga de operadores tiene posibilidades de error en comparación con otros lenguajes. Java tiene sobrecarga de métodos. La sobrecarga de métodos cumple la función de sobrecarga de operadores y elimina la posibilidad de errores.
• Java admite la sobrecarga de métodos. La sobrecarga de métodos es el concepto de una clase que tiene más de un único método con el mismo nombre pero diferentes parámetros. La identificación del método que se va a utilizar es aquí más fácil. Depende del número de argumentos o del tipo de datos de los argumentos.

Veamos un ejemplo.

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));
  }
}

Producción :

22
1100

La clase DemoClass tiene dos métodos con el mismo nombre, demo, en el ejemplo anterior. Pero estos dos métodos toman diferente número de argumentos.

Cuando pasamos dos argumentos, entra en acción el primer método de demostración, y cuando pasamos tres argumentos, entra en acción el segundo método de demostración. Así es como funciona la sobrecarga de métodos en Java.

Para simplificar el lenguaje, los desarrolladores de Java no proporcionaron la función de sobrecarga de operadores. Cada operador tiene algún significado que podemos cambiar según los requisitos del desarrollador.

Conduce a la confusión cuando varias personas están trabajando en el mismo proyecto. Los diseñadores de Java evitaron la sobrecarga de operadores en Java para evitar el uso de operadores. Hace de Java un lenguaje fácil de implementar.

Algunos lenguajes similares a Java, también conocidos como lenguajes basados ​​en JVM, admiten la sobrecarga de operadores. Estos incluyen Groovy y Kotlin.

Desarrollado por Jetbrains, Kotlin es un lenguaje de tipado estático y de alto nivel. Se ejecuta en la máquina virtual de Java o JVM e incluso se puede compilar en el código fuente de Javascript.

Uno de los principales avances de Kotlin sobre Java es que Kotlin admite la sobrecarga de operadores, a diferencia de Java.

Por otro lado, Groovy admite escritura estática y dinámica y compila en Java Virtual Machine ByteCode. Groovy también admite la sobrecarga de operadores.

Conclusión

Como respuesta a si Java admite o no la sobrecarga de operadores, Java no admite la sobrecarga de operadores. Solo una parte de Java se parece a este concepto: la concatenación de cadenas usando el operador más.

Aparte de esto, Java no le permite definir sus operadores. Sin embargo, algunos otros lenguajes basados ​​en JVM, como Java, admiten la sobrecarga de operadores.

Estos incluyen Groovy y Kotlin. Pero estos no son lo mismo que Java.