在这篇文章中,我们将深入探讨 Java 中 Operator 重载的迷人世界。尽管 Java 本身不支持运算符重载,但我们将发现 Manifold 如何使用该功能扩展 Java。我们将探讨它的好处、局限性和用例,尤其是在科学和数学代码方面。
我们还将探索 Manifold 提供的三个强大功能,这些功能增强了默认的 Java 类型安全性,同时支持令人印象深刻的编程技术。我们将讨论单元表达式、类型安全的反射编码以及编译期间修复 equals 等方法。此外,我们将介绍 Manifold 提供的解决方案,以解决关键字的一些限制
在我们开始之前,与往常一样,您可以在我的 GitHub 页面上找到本文和本系列中其他视频的代码示例。请务必查看该项目,给它加个星标,并在 GitHub 上关注我以保持更新!
算术运算符
运算符重载允许我们在代码中使用熟悉的数学符号,使其更具表现力和直观性。虽然 Java 默认不支持运算符重载,但 Manifold 提供了此限制的解决方案。
为了演示,让我们从一个执行向量算术运算的简单类开始。在标准 Java 代码中,我们定义变量,在构造函数中接受它们,并实现向量加法等方法。但是,这种方法可能很冗长且可读性较差。Vector
plus
1
public class Vec {
2
private float x, y, z;
3
4
public Vec(float x, float y, float z) {
5
this.x = x;
6
this.y = y;
7
this.z = z;
8
}
9
10
public Vec plus(Vec other) {
11
return 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) {
2
return 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-science
BigDecimal
BigDecimal
+
-
*
/
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 作为参数并返回结果的方法。此扩展使我们能够无缝地在不同类型的之间执行算术运算。目标是让这段代码编译:Integer
plus
BigDecimal
1
var z = 5 + x + y;
不幸的是,这不会与该更改一起编译。数字 5 是 primitive,而不是 Integer,让该代码工作的唯一方法是:
1
var z = Integer.valueOf(5) + x + y;
这不是我们想要的。但是,有一个简单的解决方案。我们可以为自己创建一个扩展,并依赖于订单可以无缝交换的事实。这意味着这个简单的扩展可以在不更改的情况下支持表达式:BigDecimal
5 + x + y
1
@Extension
2
public class BigDecimalExt {
3
public static BigDecimal plus(@This BigDecimal b, int i) {
4
return b.plus(BigDecimal.valueOf(i));
5
}
6
}
算术运算符列表
到目前为止,我们专注于 plus 运算符,但 Manifold 支持广泛的运算符。下表列出了方法名称及其支持的运算符:
算子 | 方法 |
+ ,+= | plus |
- ,-= | minus |
* ,*= | times |
/ ,/= | div |
% ,%= | rem |
-a | unaryMinus |
++ | inc |
-- | dec |
请注意,递增和递减运算符在前缀和后缀定位之间没有区别。两者都会导致该方法。a++
++a
inc
索引运算符
当我看到它时,对 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。但这不是我要纠结的部分。这段代码很 “不错”。这段代码绝对令人惊叹:ArrayList
List.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 倍导致 。Velocity
Mass
Momentum
Velocity
Force
Power
即使在早期实验阶段,此软件包也支持许多单元,请在此处查看它们。
您可能会注意到这里的一个大遗漏: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 {
2
int size = 5;
3
4
public int size() {
5
return size;
6
}
7
8
public void setSize(int size) {
9
this.size = size;
10
}
11
12
public boolean equals(@Self Object o) {
13
return 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 更灵活。它提供了一种简洁而富有表现力的方式来定义变量,而不会牺牲类型安全性。var
auto
auto
Auto 在使用 Tuples 时特别有用,这是本文尚未讨论的功能。它允许使用优雅简洁的代码,从而提高可读性和可维护性。您可以有效地将 auto 用作 var 的直接替代品。
最后
Manifold 的运算符重载为 Java 带来了富有表现力和直观的数学符号,增强了代码的可读性和简单性。虽然 Java 本身不支持运算符重载,但 Manifold 使开发人员能够实现类似的功能并在其代码中使用熟悉的运算符。通过利用 Manifold,我们可以编写更流畅、更具表现力的代码,尤其是在科学、数学和金融应用中。