在这篇文章中，我们将深入探讨 Java 中 Operator 重载的迷人世界。尽管 Java 本身不支持运算符重载，但我们将发现 Manifold 如何使用该功能扩展 Java。我们将探讨它的好处、局限性和用例，尤其是在科学和数学代码方面。

    我们还将探索 Manifold 提供的三个强大功能，这些功能增强了默认的 Java 类型安全性，同时支持令人印象深刻的编程技术。我们将讨论单元表达式、类型安全的反射编码以及编译期间修复 equals 等方法。此外，我们将介绍 Manifold 提供的解决方案，以解决关键字的一些限制

    在我们开始之前，与往常一样，您可以在我的 GitHub 页面上找到本文和本系列中其他视频的代码示例。请务必查看该项目，给它加个星标，并在 GitHub 上关注我以保持更新！

算术运算符

    运算符重载允许我们在代码中使用熟悉的数学符号，使其更具表现力和直观性。虽然 Java 默认不支持运算符重载，但 Manifold 提供了此限制的解决方案。

    为了演示，让我们从一个执行向量算术运算的简单类开始。在标准 Java 代码中，我们定义变量，在构造函数中接受它们，并实现向量加法等方法。但是，这种方法可能很冗长且可读性较差。Vectorplus

1
public class Vec {
2private float x, y, z;
34public Vec(float x, float y, float z) {
5this.x = x;
6this.y = y;
7this.z = z;
8}
910public Vec plus(Vec other) {
11return new Vec(x + other.x, y + other.y, z + other.z);
12}
13
}

    使用 Manifold，我们可以显着简化代码。使用 Manifold 的算子重载功能，我们可以直接使用算子将向量相加，如下所示：

1
Vec vec1 = new Vec(1, 2, 3);
2
Vec vec2 = new Vec(1, 1, 1);
3
Vec vec3 = vec1 + vec2;

    Manifold 将运算符无缝映射到适当的方法调用，使代码更简洁。这种流畅的语法类似于数学表示法，增强了代码的可读性。

    此外，Manifold 可以优雅地处理反向表示法。假设我们颠倒操作数的顺序，例如标量加向量，Manifold 交换顺序并正确执行操作。这种灵活性使我们能够以更自然、更直观的方式编写代码。

假设我们将以下内容添加到 Vec 类中：

1
public Vec plus(float other) {
2return new Vec(x + other, y + other, z + other);
3
}这将使所有这些行都有效：
爪哇岛
1
vec3 += 5.0f;
2
vec3 = 5.0f + vec3;
3
vec3 = vec3 + 5.0f;
4
vec3 += Float.valueOf(5.0f);

    在此代码中，我们演示了 Manifold 可以交换顺序以无缝调用。我们还表明 plus 等于运算符支持内置于 plus 方法支持中Vec.plus(float)

    正如前面的代码所暗示的那样，Manifold 还支持原始包装器对象，特别是在自动装箱的上下文中。在 Java 中，原始类型具有相应的包装器对象。Manifold 可以无缝地处理 primitives 及其包装器对象之间的转换，这要归功于自动装箱和取消装箱。这使我们能够在代码中互换地使用对象和基元。这有一些注意事项，我们会发现的。

BigDecimal 支持

    Manifold 超越了简单的算术，支持更复杂的场景。例如，依赖项包括对 arithmetic 的内置支持。Java 类是否用于涉及大数或金融计算的精确计算？通过使用 Manifold，我们可以使用熟悉的运算符（如 、、 和 ）对 BigDecimal 对象执行算术运算。Manifold 的集成简化了代码并确保了准确的计算。manifold-scienceBigDecimalBigDecimal+-*/BigDecimal

    一旦我们添加了正确的依赖项集，这些依赖项将方法扩展添加到类中，以下代码是合法的：BigDecimal

1
var x = new BigDecimal(5L);
2
var y = new BigDecimal(25L);
3
var z = x + y;

    在后台，Manifold 将适用的 plus、minus、times 等方法添加到类中。它通过利用我之前讨论过的类扩展来实现这一点。

装箱的限制

    我们还可以扩展现有类以支持运算符重载。Manifold 允许我们扩展类并添加接受自定义类型或执行特定操作的方法。例如，我们可以扩展该类并添加一个接受 BigDecimal 作为参数并返回结果的方法。此扩展使我们能够无缝地在不同类型的之间执行算术运算。目标是让这段代码编译：IntegerplusBigDecimal

1
var z = 5 + x + y;

不幸的是，这不会与该更改一起编译。数字 5 是 primitive，而不是 Integer，让该代码工作的唯一方法是：

1
var z = Integer.valueOf(5) + x + y;

    这不是我们想要的。但是，有一个简单的解决方案。我们可以为自己创建一个扩展，并依赖于订单可以无缝交换的事实。这意味着这个简单的扩展可以在不更改的情况下支持表达式：BigDecimal5 + x + y

1
@Extension
2
public class BigDecimalExt {
3public static BigDecimal plus(@This BigDecimal b, int i) {
4return b.plus(BigDecimal.valueOf(i));
5}
6
}

算术运算符列表

    到目前为止，我们专注于 plus 运算符，但 Manifold 支持广泛的运算符。下表列出了方法名称及其支持的运算符：

算子	方法
+,+=	plus
-,-=	minus
*,*=	times
/,/=	div
%,%=	rem
-a	unaryMinus
++	inc
--	dec

    请注意，递增和递减运算符在前缀和后缀定位之间没有区别。两者都会导致该方法。a++++ainc

索引运算符

    当我看到它时，对 index 运算符的支持让我完全措手不及。这完全改变了游戏规则......index 运算符是我们用来按索引获取数组值的方括号。为了让您了解我在说什么，这是 Manifold 中的有效代码：

1
var list = List.of("A", "B", "C");
2
var v = list[0];

    在这种情况下， will be ，并且代码等效于调用 .索引运算符无缝映射到 get 和 set 方法。我们也可以使用以下方法进行作业：v“A”list.get(0)

1
var list = new ArrayList<>(List.of("A", "B", "C"));
2
var v = list[0];
3
list[0] = "1";

    请注意，我必须将 List 包装在 since 中，返回一个不可修改的 List。但这不是我要纠结的部分。这段代码很 “不错”。这段代码绝对令人惊叹：ArrayListList.of()

1
var map = new HashMap<>(Map.of("Key", "Value"));
2
var key = map["Key"];
3
map["Key"] = "New Value";

    您正在 Manifold 中读取有效代码。索引运算符用于在 map 中查找。请注意，map 具有 method，而不是 method。这是一个令人讨厌的不一致，Manifold 用扩展方法解决了这个问题。然后，我们可以通过 operator 使用对象在 map 中查找。put() set

关系运算符和相等运算符

我们还有很多事情要讲......我们是否可以编写这样的代码（参考前面的对象）：

1
if(vec3 > vec2) {
2// …
3
}

    请注意，该类具有 times 方法的多个重载版本，它们接受不同的对象类型。一个时代会产生 。A 倍导致 。VelocityMassMomentumVelocityForcePower即使在早期实验阶段，此软件包也支持许多单元，请在此处查看它们。

您可能会注意到这里的一个大遗漏：Currency。我很想有这样的东西：

1
var sum = 50 USD + 70 EUR;

    如果您查看该代码，问题应该很明显。我们需要一个汇率。如果没有汇率和可能的转换成本，这就没有意义。财务计算的复杂性并不能很好地转化为代码的当前状态。我怀疑这就是这仍然是实验性的原因。我很好奇如何优雅地解决这样的事情。

操作员超载的陷阱

    虽然 Manifold 提供了强大的操作员超载功能，但重要的是要注意潜在的挑战和性能考虑因素。Manifold 的方法可能会导致额外的方法调用和对象分配，这可能会影响性能，尤其是在性能关键型环境中。考虑优化技术（例如减少不必要的方法调用和对象分配）以确保高效的代码执行至关重要。

让我们看看这段代码：

1
var n = x + y + z;

从表面上看，它似乎高效而简短。它物理转换为以下代码：

var n = x.plus(y).plus(z);

    这仍然很难发现，但请注意，为了创建结果，我们调用了两个方法并分配了至少两个对象。更有效的方法是：

var n = x.plus(y, z);

    这是我们经常为高性能矩阵计算所做的优化。您需要注意这一点，并了解如果性能很重要，操作员在后台做什么。我不想暗示 Operator 天生就慢。事实上，它们与方法调用一样快，但有时调用的特定方法和分配数量并不直观。

类型安全特性

    以下内容与运算符重载无关，但它们是第二个视频的一部分，因此我认为它们作为关于类型安全的广泛讨论的一部分是有意义的。我最喜欢 Manifold 的一点是它支持严格的类型化和编译时错误。对我来说，两者都代表了 Java 的核心精神。

JailBreak：类型安全反射

    @JailBreak是一项功能，用于授予对类中 private 状态的访问权限。虽然这听起来很糟糕，但提供了比使用传统反射访问私有变量更好的替代方案。通过越狱一个类，我们可以无缝地访问它的私有状态，而编译器仍然执行类型检查。从这个意义上说，它是两害相权取其轻的。如果你要做一些糟糕的事情（访问私有状态），那么至少让编译器检查它。@JailBreak

    在下面的代码中，value 数组是 String 的私有数组，但我们可以借助注释来操作它。此代码将打印 ：@JailBreak“Ex0osed…”

1
@Jailbreak String exposedString = "Exposed...";
2
exposedString.value[2] = '0';
3
System.out.println(exposedString);

    JailBreak 也可以应用于静态字段和方法。但是，访问静态成员需要为变量分配 null，这似乎有悖常理。尽管如此，此功能提供了一种更可控且类型安全的方法来访问内部状态，从而最大限度地降低了与使用反射相关的风险。

1
@Jailbreak String str = null;
2
str.isASCII(new byte[] { 111, (byte)222 });

    最后，Manifold 中的所有对象都注入了一个方法。此方法可以像这样使用（请注意，这是一个私有字段）：jailbreak()fastTime

1
Date d = new Date();
2
long t = d.jailbreak().fastTime;

自注释：强制方法参数类型

    在 Java 中，某些 API 接受对象作为参数，即使可以使用更具体的类型也是如此。这可能会导致运行时出现潜在问题和错误。但是，Manifold 引入了 Comments，这有助于强制执行作为参数传递的对象类型。@Self

    通过使用 注释参数，我们明确表示仅接受指定的对象类型。这确保了类型安全并防止意外使用不兼容的类型。使用此注释，编译器可以在开发过程中捕获此类错误，从而降低在生产中遇到问题的可能性。@Self

让我们看看我之前的帖子：MySizeClass

1
public class MySizeClass {
2int size = 5;
34public int size() {
5return size;
6}
78public void setSize(int size) {
9this.size = size;
10}
1112public boolean equals(@Self Object o) {
13return o != null && ((MySizeClass)o).size == size;
14}
15
}

请注意，我添加了一个 equals 方法，并使用 Self 注释了该参数。如果我删除 Self 注释，此代码将编译：

1
var size = new MySizeClass();
2
size.equals("");
3
size.equals(new MySizeClass());

使用 annotation 时，字符串比较在编译过程中将失败。@Self

auto 关键字：var 的更强替代方案

    我不是这个关键词的忠实粉丝。我觉得它并没有简化太多，而且价格是编码到实现而不是接口。我理解 Oracle 的开发人员为什么选择这条路。保守的决定是我觉得 Java 如此吸引人的主要原因。Manifold 的好处是可以在这些约束之外工作，并且它提供了一个更强大的替代方案，称为 。可用于字段和方法返回值，使其比 var 更灵活。它提供了一种简洁而富有表现力的方式来定义变量，而不会牺牲类型安全性。varautoauto

    Auto 在使用 Tuples 时特别有用，这是本文尚未讨论的功能。它允许使用优雅简洁的代码，从而提高可读性和可维护性。您可以有效地将 auto 用作 var 的直接替代品。

最后

    Manifold 的运算符重载为 Java 带来了富有表现力和直观的数学符号，增强了代码的可读性和简单性。虽然 Java 本身不支持运算符重载，但 Manifold 使开发人员能够实现类似的功能并在其代码中使用熟悉的运算符。通过利用 Manifold，我们可以编写更流畅、更具表现力的代码，尤其是在科学、数学和金融应用中。