探究這些下一代 JVM 語言如何處理操作符重載
編程語言中的好理念可以延續並擴展到其他語言，就像美酒一樣歷久彌香。因此，不足奇怪的是，Java 下一代語言 — Groovy、Scala 和 Clojure — 具有很多共同的特性。在本期和下一期 Java 下一代 文章中，我將探討每種語言語法中功 能清單的一致性。我從能夠重載操作符這個特性說起 — 克服了Java 語言中長期存在的一個缺點。
操作符重 載
如果您改造過 Java BigDecimal 類，可能看到過類似於清單 1 的代碼：
清單 1. Java 代碼中的 Lackluster BigDecimal 支持
BigDecimal op1 = new BigDecimal(1e12);
BigDecimal op2 = new BigDecimal(2.2e9);
// (op1 + (op2 * 2)) / (op1/(op1 + (op2 * 1.5e2))
BigDecimal lhs = op1.add(op2.multiply(BigDecimal.valueOf(2)));
BigDecimal rhs = op1.centeride(
op1.add(op2.multiply(BigDecimal.valueOf(1.5e2))),
RoundingMode.HALF_UP);
BigDecimal result = lhs.centeride(rhs);
System.out.println(String.format("%,.2f", result));
在 清單 1 中，我試圖實現注釋中的這個公式 。在 Java 編程中，因無法重載數學操作符，使得我只能求助於方法調用。靜態導入可以解決問題，但是對於所選擇的上下 文，顯然需要適當的操作符重載。最初的 Java 工程師故意從語言上忽略操作符重載，不過這感覺增加了太大的復雜性。但 是經驗表明，因缺乏這一特性而強加給開發人員的復雜性更甚於潛在的濫用機會。
用稍微各不相同的方式，所有三 種 Java 下一代語言都實現了操作符重載。
Scala 的操作符
Scala 通過放棄操作符與方法之間的區 別而允許操作符重載。操作符只不過是具有特殊名稱的方法。例如，要重寫乘法操作符，可以重寫 * 方法。[* 是一個有效 的方法名稱，這就是 Scala 使用下劃線 (_) 符號而不是 Java 星號 (*) 符號來代表導入的原因之一。]
我 使用復數來說明重載。復數是一種數學表示，包括實部和虛部，例如通常寫作 3 + 4i 這樣的形式。復數在很多科學領域都 很常見，包括工程學、物理學、電磁學以及其他理論。清單 2 顯示了復數的 Scala 實現：
清單 2. Scala 復數
final class Complex(val real:Int, val imaginary:Int) {
require (real != 0 || imaginary != 0)
def +(operand:Complex) =
new Complex(real + operand.real, imaginary + operand.imaginary)
def +(operand:Int) =
new Complex(real + operand, imaginary)
def -(operand:Complex) =
new Complex(real - operand.real, imaginary - operand.imaginary)
def -(operand:Int) =
new Complex(real - operand, imaginary)
def *(operand:Complex) =
new Complex(real * operand.real - imaginary * operand.imaginary,
real * operand.imaginary + imaginary * operand.real)
override def toString() =
real + (if (imaginary < 0) "" else "+") + imaginary + "i"
override def equals(that:Any) = that match {
case other :Complex => (real == other.real) && (imaginary == other.imaginary)
case _ => false
}
override def hashCode():Int =
41 * ((41 + real) + imaginary)
}
Scala 通過折疊不必要的腳手架代碼，大大降低了 Java 語言的啰嗦程度。例如，在 清單 2 中，類中 的構造函數參數和字段與類定義一起出現。在本例中，類的主體充當構造函數，所以對 require() 方法的調用在第一次實 例化操作過程中驗證值的存在。因為 Scala 自動提供字段，所以類的其余部分包含方法定義。對於 +、- 和 * 操作符，我 都聲明了接受 Complex 數作為參數的同名方法。復數的乘法不及加法和減法那麼直觀。清單 2 中已重載的 * 方法實現公 式：
(x + yi)(u + vi) = (xu - yv) + (xv + yu)i
清單 2 中的 toString() 方法例示了 Java 下 一代語言之間的另外一個共同點：使用表達式而不是語句。在 toString() 方法中，虛部為正時我必須提供加號 (+)，否則 ，虛部的隱式減號就足夠了。在 Scala 中，if 是一個表達式，而不是語句，不再需要 Java 三元操作符 (?:)。
實 際上，增加的 +、- 和 * 方法都跟標准的操作符沒什麼區別，如清單 3 中的單元測試所示：
清單 3. 練習 Scala 復數
class ComplexTest extends FunSuite {
test("addition") {
val c1 = new Complex(1, 3)
val c2 = new Complex(4, 5)
assert(c1 + c2 === new Complex(1+4, 3+5))
}
test("subtraction") {
val c1 = new Complex(1, 3)
val c2 = new Complex(4, 5)
assert(c1 - c2 === new Complex(1-4, 3-5))
}
test("multiplication") {
val c1 = new Complex(1, 3)
val c2 = new Complex(4, 5)
assert(c1 * c2 === new Complex(
c1.real * c2.real - c1.imaginary * c2.imaginary,
c1.real * c2.imaginary + c1.imaginary * c2.real))
}
}
清單 3 中的測試失敗，揭示了一個有趣的不一致性。後面討論 關聯性 時，我指出並解決了這個問題。但是， 現在簡單介紹一下 Groovy 和 Clojure 中的重載。
Groovy 的映射
通過提供您可以重寫的映射方法，Groovy 重載任何 Java 操作符。（例如，要重寫 + 操作符，您可在 Integer 類重寫 plus() 方法。）在 “函數設計模式，第 3 部分”，即我 函數式思維 系列（探討函數語言中的可擴展性）中的一期文章，我用同一個復數例子詳細介紹了 Groovy 的 操作符重載。
在 Groovy 中，您無法創建新的操作符（盡管可以創建新方法）。一些框架（比如 Spock 測試框架 ；參見 參考資料）重載難以理解卻實際存在的操作符，比如 >>>。Scala 和 Clojure 都更加一致地對待操作符 和方法，盡管方式有所不同。
Groovy 也引入了幾個方便的新操作符，比如 ?. 和 Elvis 操作符 (?:)，—前者是安 全導航 操作符，它確保所有調用者都不為空，後者是 Java 三元操作符的簡寫形式，對於輕松提供默認值非常有用。 Groovy 對新操作符沒有擴展方法，防止了開發人員重載它們。至於開發人員為什麼想要重載它們，原因不是很清楚：操作 符重載的一個基本原因在於，以前的操作符使用經驗可以增加代碼的可讀性。您不可能在 Groovy 外面培養這些操作符的使 用經驗。如果您為方便性使用操作符時破壞了代碼可讀性，那麼操作符重載將變成危險的事情。
Clojure 的操作符
跟 Scala 中一樣，Clojure 中的操作符也只是帶有符號名稱的方法。因此，比如說您可以隨便為自己的定制類型創 建一個 + 方法。然而，要在 Clojure 中正確重寫操作符，您必須理解協議 和一種用於從公共內核生成一組方法的技術。 我將在下一期文章中討論這一內容。
關聯性
操作符關聯性 是指操作符是等式左側還是右側的方法。Scala 對空格的使用不同於大多數其他語言，因為基本上任何 Scala 方法都可以充當操作符。例如，表達式 x + y 實際上就是方 法調用 x.+(y)，如清單 4 中 Scala REPL（解釋器）會話中所示：
清單 4. Scala 中的空格轉化
scala> val sum1 = x.+(y)
sum1:Int = 22
scala> val sum2 = (12).+(10)
sum2:Int = 22
清單 4 中可以看到，空格轉化也適用於常量。願意的話，您可以將 Scala 中的所有方法都看作操 作符。例如，String 類具有一個 indexOf() 方法，它返回被作為參數傳遞的字符串中的索引位置。在 Scala 中， 您可以用傳統方式通過 s.indexOf('a') 調用過它，或者作為操作符 — 像 s indexOf 'a' 中一樣。（ 這個具體的方法很有趣，因為它有一個已重載的版本，接受一個額外的參數來指定搜索開始處的索引位置。您仍然可以使用 操作符表示法調用它，但是必須將參數放置在括號中，就像 s indexOf('a', 3) 中一樣。）
Groovy 遵循 Java 關聯性約定，所以特定操作符的規則由語言定義。Clojure 根本不關注關聯性；它的 Lisp 語法不依賴於關聯性，因 為所有語句都是意義明確的。
由於 Scala 的目標之一就是允許開發人員可以將任何東西都用作操作符，所以它不 能依賴於任何關聯性規則。該語言如何才能允許特殊的操作符卻仍然建立規則？Scala 以一種支持開發人員最大自由度的創 新方式解決了這個問題 — 使用操作符命名約定。默認情況下，Scala 中操作符是左關聯的：表達式分解為一個對左操作數 的方法調用，例如，這意味著表達式 x + y 分解為 x.+(y)。然而，如果方法名稱以 : 結尾，則操作符是右關聯的。例如 ，i +: j 調用轉化成 j.+:(i)。
關聯性解釋了為什麼 清單 3 中的測試無法得到正確的結果。清單 2 中的 Scala Complex 定義中，我實現了 + 和 - 操作符的版本，它們既接受 Complex，也接受 Int 參數類型。這種類型的靈活 性允許復數與一般整數（即實部為零的復數）相互操作。清單 5 說明了單元測試中的互操作性：
清單 5. 混合類型 的測試
test("mixed addition from Complex") {
val c1 = new Complex(1, 3)
assert(new Complex(7, 3) == c1 + 6)
}
test("mixed subtraction from Complex") {
val c1 = new Complex(10, 3)
assert(new Complex(5, 3) == c1 - 5)
}
清單 5 中的兩個測試都能通過，沒有問題 — 操作符方法的 Int 版本開始了。然而，如果我嘗試以下測試，它 則會失敗：
test("mixed subtraction from Int") {
val c1 = new Complex(10, 3)
assert(new Complex(15, 3) == 5 + c1)
}
兩個測試之間的細微差別就在於關聯性上。記住，在本例中，Scala 調用左操作符的方法，這意味著它試圖開始 一個為 Int 定義的方法（它知道如何處理復數）。
為了解決這個問題，我在 Int 和 Complex 之間定義了一個隱式 強制類型轉換。有多種方式展示這種轉換，我將在以後幾期文章中更加詳細地介紹。在本例中，我創建了一個伴生對象，即 Complex，這是一個用於放置 Java 語言中聲明為 static 的方法的地方：
final object Complex {
implicit def intToComplex(x:Int) = new Complex(x, 0)
}
該定義包含單個方法，此方法接受一個 Int 並將之返回為 Complex。將這個聲明作為 Complex 類放置在相同的 源文件中，然後我通過 import nealford.javaNext.complexnumbers.Complex.intToComplex 命令在我的測試案例中導入該 方法，可以支持隱式轉換。有了轉換之後，測試案例成功通過，因為測試知道如何處理通過操作符發出的方法調用。
優先級
操作符優先級（或者操作順序）是指規定潛在存在歧義的情況下操作發生順序的語言規則。對於公共 操作符，Groovy 依賴於 Java 優先級規則；對於自己的定制操作符，它定義自己的規則。Clojure 不具有或不需要優先級 規則；因為所有代碼都以括號形式編寫，不再會出現中綴表示法中固有的歧義性。
Scala 使用操作符名稱的第一個 字符來確定操作順序，優先層次是：
所有其他特殊符號
* / %
+ -
:
= !
< >
&
^
|
所有字母
所有分配操作符
以較高級別字符開始的操作符具有較 高的優先級。例如，表達式 x *** y ||| z 將分解為 (x.***(y)).|||(z)。該規則惟一的例外是分配語句，或者任何以等 號 (=) 結尾的操作符，它們自動具有最低優先級。
結束語
Java 下一代語言的一個共同目標是，簡化那些 影響著 Java 語言的繁瑣限制。操作符重載是每種語言解決這個問題的一個重要途徑。所有三種語言都允許操作符重載，只 是實現的方式有所不同。處理關聯性和優先級這類問題的方式的細微差別表明了，各個語言部分是如何緊密聯系的。 Clojure 的有趣方面之一是它的語法 — 因為每個表達式都是括號形式的 — 消除了優先級和關聯性中的歧義。
在下一期文章中，我將探究 “一切都是對象” 這一說法在 Java 下一代語言中的深層含義。
