Java 缺失的特性:操作符重载
本文介绍了什么是操作符重载、为什么需要操作符重载、如何在Java中实现操作符重载以及一些建议。
什么是操作符重载
为什么需要操作符重载
private static final BigInteger BI_2 = BigInteger.valueOf(2);
常规写法:
BigInteger res = a.multiply(a).subtract(BI_2.multiply(a).multiply(b)).add(b.multiply(b));
假设可以对 Java 中的 *、+、- 进行操作符重载,那么我们就可以直接这样写:
BigInteger res = a * a - BI_2 * a * b + b * b;
所以,对于非原始类型的数值运算,如果能够进行操作符重载,至少有 2 个好处:
-
代码写起来更简单,不容易出错 -
代码更容易阅读,不会一堆括号嵌套
如何在 Java 中实现操作符重载
算数操作符
![图片](https://img2023.cnblogs.com/blog/27422/202303/27422-20230315105650383-1271865634.png)
—— 用过 Kotlin 的同学应该会会心一笑,这就是模仿的 Kotlin 的操作符重载。
为了方便举例说明,我们定义一个数值类型 Num:
public class Num {
private final int v;
public Num(int v) {
this.v = v;
}
public Num plus(Num that) {
return new Num(this.v + that.v);
}
public Num minus(Num that) {
return new Num(this.v - that.v);
}
public Num times(Num that) {
return new Num(this.v * that.v);
}
}
对于下面的代码:
Num a = new Num(1);
Num b = new Num(2);
Num c = a + b - a;
Manifold 在编译期处理之后,会变成:
Num c = a + a * b - b;
public class Num {
...
public Num plus(Num that) {
return new Num(this.v + that.v);
}
public Num plus(int i) {
return new Num(v + i);
}
}
Num c = a + 1 + b;
在 Manifold 处理之后:
值得注意的是,因为 + 和 * 都是满足交换律的,所以 a + b 首先会去对象 a 中寻找符合的 plus 方法,如果 a 中存在,则执行的是 a.plus(b);如果 a 中不存在,而 b 中存在符合的 plus 方法,则执行的是 b.plus(a)。a * b 同理。
![图片](https://img2023.cnblogs.com/blog/27422/202303/27422-20230315105652077-167374811.png)
比较操作符
![图片](https://img2023.cnblogs.com/blog/27422/202303/27422-20230315105650462-1985458372.png)
public class Num implements Comparable<Num> {
...
@Override
public int compareTo(Num that) {
return this.v - that.v;
}
}
那么对于这样的代码:
Num a = new Num(1);
Num b = new Num(2);
if (a > b) {
System.out.println("a > b");
}
if (a < b) {
System.out.println("a < b");
}
运行代码会输出 a < b,因为代码在被 Manifold 处理之后会变为:
-
如果是 EqualityMode.CompareTo ,则 == 和 != 的重载分别对应的是 compareTo 方法返回值为 0 和 非0 的情况。 -
如果是 EqualityMode.Equals ,则 == 和 != 的重载分别对应的是 equals 方法返回值为 true 和 false 的情况。 -
如果是 EqualityMode.Identity ,那使用的是 Java 的默认实现,即比较对象的引用地址是否相同。
而 equalityMode 默认的方法返回值为 EqualityMode.Equals,即 Manifold 默认使用 equals 方法来进行 == 和 != 的判断。当然,你也可以不使用 Manifold 的 equalityMode 这套逻辑,直接实现自己的 compareUsing 方法,处理各种 Operator 的比较逻辑。
public class Num implements ComparableUsing<Num> {
...
@Override
public int compareTo(Num that) {
return this.v - that.v;
}
@Override
public boolean equals(Object obj) {
if (this == obj) { return true; }
if (obj instanceof Num) {
Num that = (Num) obj;
return this.v == that.v;
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(v);
}
}
Num a = new Num(1);
Num b = new Num(1);
if (a == b) {
System.out.println("a == b");
}
if (a != b) {
System.out.println("a != b");
}
你应该也发现了,如果某个类型 T 要实现 ComparableUsing<T>,那么说明 T 一定是 Comparable<T>。也就是说,如果你想要对 T 重载 == 和 !=,则要求 T 一定是可比较的。Manifold 之所以这样做,而不是为重载 == 和 != 提供单独的接口,是因为作者目前认为用 == 和 != 来代替 equals,弊大于利 —— 毕竟用 equals 来比较两个对象是否相等这件事,在 Java 中太深入人心了。所以目前 Manifold 作者希望大家只对数值和量词这类的对象使用 == 和 !=,不要产生滥用行为。
索引操作符
![图片](https://img2023.cnblogs.com/blog/27422/202303/27422-20230315105650402-949057047.png)
@Extension
public class MapExt {
public static <K, V> V set(@This Map<K, V> map, K key, V value) {
return map.put(key, value);
}
}
然后我们就可以这样写代码了:
int[] nums = {1, 2, 3};
int value = nums[0] = 10;
List<String> list = Arrays.asList("a", "b", "c");
String value = list[0] = "A";
Manifold 处理之后,代码会变成:
单位操作符
public class DateTimeUnit {
private static final
DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public LocalDateTime postfixBind(String value) {
return LocalDateTime.parse(value, FORMATTER);
}
}
postfixBind 表示这个单位是“后缀单位”,就是你看到的 "xxx"dt,dt 在 "xxx" 的后面。Manifold 同时也支持“前缀单位”,对应的方法是 prefixBind,比如:
public class DateTimeUnit {
...
public LocalDateTime prefixBind(String value) {
return LocalDateTime.parse(value, FORMATTER);
}
}
添加了 prefixBind(String) 后,那么就可以这样定义 LocalDateTime:
public class BigIntegerUnit {
public BigInteger postfixBind(Integer value) {
return BigInteger.valueOf(value);
}
public BigInteger postfixBind(String value) {
return new BigInteger(value);
}
}
配合 Manifold 的 auto(类似于 Java10 提供的 var,但是 auto 还可以用来定义属性):
public class MapEntryBuilder {
public <K> EntryKey<K> postfixBind(K key) {
return new EntryKey<>(key);
}
public static class EntryKey<K> {
private final K key;
public EntryKey(K key) {
this.key = key;
}
public <V> Map.Entry<K, V> prefixBind(V value) {
return new AbstractMap.SimpleImmutableEntry<>(key, value);
}
}
}
那么,便可以通过下面这种方式来创建 Map.Entry(先通过 to.postfixBind 创建 EntryKey,再通过 EntryKey 的 prefixBind 方法创建 Map.Entry):
![图片](https://img2023.cnblogs.com/blog/27422/202303/27422-20230315105650531-2076158993.png)
@Extension
public class MapExt {
@Extension
@SafeVarargs
public static <K, V> Map<K, V> of(Map.Entry<K, V>... entries) {
Map<K, V> map = new LinkedHashMap<>(entries.length);
for (Map.Entry<K, V> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}
return Collections.unmodifiableMap(map);
}
}
那么你可以这样创建 Map:
建议
[1]https://github.com/manifold-systems/manifold
[2]https://openjdk.org/jeps/8277163
作者|周密(之叶)
本文来自博客园,作者:古道轻风,转载请注明原文链接:https://www.cnblogs.com/88223100/p/Javas-missing-feature-operator-overloading.html