迹忆客 专注技术分享

本文讨论 Java 是否支持用户定义的运算符重载。

Java 中的运算符重载

运算符重载是如何在用户定义的类型中实现运算符。它使用基于我们传递的参数类型和数量的定制逻辑。

使用运算符重载，我们可以指定用户定义的操作实现。语法糖是这个的另一个术语。操作中涉及的算子可以是结构体类型，也可以是自定义类。

例如，使用加号运算符 + 将两个数字相加并连接两个字符串是运算符重载的最简单情况。

但是，Java 不支持运算符重载，除了一种情况，即使用加号运算符的字符串连接。

这是完整的示例。

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

输出：

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

在此示例中，加号运算符将两个整数相加并连接两个字符串。它是 Java 支持的唯一运算符重载。

除此之外，Java 不支持用户定义的运算符重载。Java 中唯一接近运算符重载的部分是处理连接字符串的+。

它导致常量的编译时连接或运行时连接。但是，在 Java 中，我们不能定义我们的操作符，它们的行为是这样的。

尽管我们可以使用加号运算符在 Java 中连接字符串，但 Java 有一个内置的 concat() 方法，它消除了执行运算符重载的需要。concat() 方法在给定字符串的末尾附加另一个字符串。

我们应该指定字符串以按照我们想要的顺序获取组合字符串。

语法：

String resultant = String1.concat(String2)

它将在第一个字符串的末尾添加第二个字符串。下面的示例使用 concat() 方法将两个字符串放在一起。

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

输出：

Enter a string:
Hello
Enter another string:
World
HelloWorld

请注意，在这里，我们没有使用加号运算符进行字符串连接，我们仍然可以借助 concat() 方法来组合两个字符串。

Java 不支持运算符重载的原因

我们可以在 C++ 中重新定义大多数内置运算符，但在 Java 中则不行。这是由于以下原因。

• 运算符重载增加了代码复杂性。如果我们重载 Java 中的运算符，Java 中的 Java 虚拟机 (JVM) 需要付出额外的努力来找出在任何特定语句中使用的运算符的实际功能。它使处理相当复杂。
• 运算符重载会在程序中引入错误。运算符重载会在程序员之间造成混乱。此外，与其他语言相比，使用支持运算符重载的语言可能会出错。Java 有方法重载。方法重载提供了运算符重载的功能并消除了错误的范围。
• Java 支持方法重载。方法重载是指一个类具有多个同名但参数不同的方法。在此更容易识别要使用的方法。这取决于参数的数量或参数的数据类型。

让我们看一个例子。

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

输出：

22
1100

在上面的示例中，类 DemoClass 有两个同名的方法 demo。但这两种方法采用不同数量的参数。

当我们传递两个参数时，第一个演示方法开始起作用，当我们传递三个参数时，第二个演示方法开始起作用。这就是方法重载在 Java 中的工作方式。

Java 的开发者为了保持语言的简单，并没有提供运算符重载的特性。每个运算符都有一些含义，我们可以根据开发人员的要求进行更改。

当多人在同一个项目上工作时，它会导致混乱。Java 设计者避免在 Java 中重载运算符以避免使用运算符。它使 Java 成为一种易于实现的语言。

一些类似 Java 的语言，也称为基于 JVM 的语言，支持运算符重载。其中包括 Groovy 和 Kotlin。

Kotlin 由 Jetbrains 开发，是一种高级静态类型语言。它在 Java 虚拟机或 JVM 上运行，甚至可以编译成 Javascript 源代码。

Kotlin 相对于 Java 的主要进步之一是 Kotlin 支持运算符重载，这与 Java 不同。

另一方面，Groovy 支持静态和动态类型，并编译为 Java 虚拟机字节码。Groovy 还支持运算符重载。

结论

作为 Java 是否支持运算符重载的答案，Java 不支持运算符重载。Java 只有一部分类似于这个概念：使用加号运算符进行字符串连接。

除此之外，Java 不允许你定义运算符。但是，其他一些基于 JVM 的语言，如 Java，支持运算符重载。

其中包括 Groovy 和 Kotlin。但这些与 Java 不同。