本文介紹了什麼是操作符重載、為什麼需要操作符重載、如何在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 中實現操作符重載
算數操作符
—— 用過 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 同理。
比較操作符
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 作者希望大家只對數值和量詞這類的對象使用 == 和 !=，不要產生濫用行為。
索引操作符
@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）：
@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
