是否可以在 Java 中重载运算符？ [复制]

Question

这个问题在这里已经有了答案：

Java中的运算符重载（10个答案）

4年前关闭。

我有以下课程，它描述了 XY 表面上的一个点：

class Point{
    double x;
    double y;

    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }
}

所以我想叠加+和-运算符来编写运行以下代码的可能性：

Point p1 = new Point(1, 2);
Point p2 = new Point(3, 4);
Point resAdd = p1 + p2; // answer (4, 6)
Point resSub = p1 - p2; // answer (-2, -2)

我怎样才能在 Java 中做到这一点？ 或者我应该使用这样的方法：

public Point Add(Point p1, Point p2){
    return new Point(p1.x + p2.x, p1.y + p2.y);
}

提前致谢！

Answer 1

您不能在 Java 中执行此操作。 您必须在Point类中实现plus或add方法。

class Point{
    public double x;
    public double y;

    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }

    public Point add(Point other){
        this.x += other.x;
        this.y += other.y;
        return this;
    }
}

用法

Point a = new Point(1,1);
Point b = new Point(2,2);
a.add(b);  //=> (3,3)

// because method returns point, you can chain `add` calls
// e.g., a.add(b).add(c)

Answer 2

尽管您不能在纯 Java 中做到这一点，但您可以使用java-oo 编译器插件来做到这一点。 您需要为 + 运算符编写add方法：

public Point add(Point other){
   return new Point(this.x + other.x, this.y + other.y);
}

和 java-oo 插件只是对这些方法调用进行脱糖操作。

Answer 3

Java 中没有运算符重载。 显然是出于口味的原因。 真可惜。

（有些人会声称 Java 确实有重载，因为+和String以及自动装箱/拆箱。）

让我们谈谈值类型。

许多早期的课程（和一些后期的课程）把这个弄得一团糟。 特别是在 AWT 中。 在 AWT 中，您应该在各处显式地制作简单值的副本。 几乎可以肯定，您想让值类型不可变 - 类应该是 final 并且它不应该改变状态（通常所有final字段都指向有效的不可变）。

所以：

public final class Point {
    private final int x;
    private final int y;

    private Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public static of(int x, int y) {
        return new Point(x, y);
    }

    public int x() {
        return x;
    }
    public int y() {
        return y;
    }
    public Point add(Point other) {
        return of(x+other.x, y+other.y);
    }

    // Standard fluffy bits:
    @Override public int hashCode() {
        return x + 37*y;
    }
    @Override public boolean equals(Object obj) {
        if (!(obj instanceof Point)) {
            return false;
        }
        Point other = (Point)obj;
        return x==other.x && y==other.y;
    }
    @Override public String toString() {
        return "("+x+", "+y+")";
    }
}

原始代码混淆了int和double ，所以我选择了一个。 如果您使用double ，则应排除NaN 。 “点”倾向于暗示绝对点，添加没有意义。 “矢量”或“维度”可能更合适，具体取决于您的意图。

我隐藏了构造函数，因为身份并不重要。 可能的值可以被缓存。 比如说，在零点上添加一个点是很常见的，所以不需要创建点。

您可能需要一个可变版本，例如用作累加器。 这应该是一个没有继承关系的独立类。 可能不是在简单的情况下，但无论如何我都会展示它：

public final class PointBuilder {
    private int x;
    private int y;

    public PointBuilder() {
    }
    public PointBuilder(Point point) {
        this.x = point.x;
        this.y = point.y;
    }
    public Point toPoint() {
        return new Point(x, y);
    }

    public PointBuilder x(int x) {
        this.x = x;
        return this;
    }
    public PointBuilder y(int y) {
        this.y = y;
        return this;
    }
    public PointBuilder add(Point other) {
        this.x += other.x;
        this.y += other.y;
        return this;
    }
}

Answer 4

您不能在 Java 中执行此操作，因为 Java 中没有运算符重载。

您必须使用您提到的第二个选项：

编辑：您可以在 Point 类本身中Add方法

public Point Add(Point other){
    return new Point(this.x + other.x, this.y + other.y);
}

Answer 5

您不能在 Java 中重载运算符。 您将需要在Point类中处理此问题。

Answer 6

您不能覆盖 Java 中的运算符。 这就是为什么不应该在 Java 中实现任何非平凡的数学（尤其是几何）运算的原因之一（上面的Point类就是这样的一个类，如果你想让它做一些实际的工作，例如线与线的交点，你最好用C++来做）。