近十幾年來，面向對象語言設計的要素一直是繼承的核心。不支持繼承的語言（如 Visual Basic）被嘲諷是 “玩具語言” ，不適合真正的工作。與此同時，支持繼承的語言所采用的支持方法五花八門，導致了許多爭論。多重繼承是否真的必不可少（就像 C++ 的創作者認定的那樣），它是否不必要而丑陋的（就像 C# 和 Java 的創作者堅信的那樣）？Ruby 和 Scala 是兩種較新的語言，采取了多重繼承的這種方法 — 正如我在上期介紹 Scala 的特征時所討論的那樣（參見 參考資料）。
與所有 傑出的語言一樣，Scala 也支持實現繼承（參見 參考資料）。在 Java 語言中，單一實現繼承模型允許您擴展基類，添加新方法和字段等。盡管存在某些句法變更，Scala 的實現繼承依然類似於 Java 語言中的實現。不同的是 Scala 融合了對象和函數語言設計，這非常值得我們在本期文章中進行討論。
普通 Scala 對象
與本系列之前的文章類似，我將使用 Person 類作為起點，探索 Scala 的繼承系統。清單 1 展示了 Person 的類定義：
清單 1. 嘿，我是人類
// This is Scala
class Person(val firstName:String, val lastName:String, val age:Int)
{
def toString = "[Person: firstName="+firstName+" lastName="+lastName+
" age="+age+"]"
}
Person 是一個非常簡單的 POSO（普通 Scala 對象，Plain Old Scala Object），具有三個只讀字段。您可能會想起，要使這些字段可以讀寫，只需將主構造函數聲明中的 val 更改為 var 即可
無論如何，使用 Person 類型也非常簡單，如清單 2 所示：
清單 2. PersonApp
// This is Scala
object PersonApp
{
def main(args : Array[String]) : Unit =
{
val bindi = new Person("Tabinda", "Khan", 38)
System.out.println(bindi)
}
}
這算不上什麼令人驚訝的代碼，但給我們提供了一個起點。
Scala 中的抽象方法
隨著該系統的發展，越來越明顯地意識到 Person 類缺乏一個成為 Person 的重要部分，這個部分是做些事情 的行為。許多人都會根據我們在生活中的作為來定義自己，而不是根據現有和占用的空間。因此，我會添加一個新方法，如清單 3 所示，這賦予了 Person 一些意義：
清單 3. 很好，做些事情！
// This is Scala
class Person(val firstName:String, val lastName:String, val age:Int)
{
override def toString = "[Person: firstName="+firstName+" lastName="+lastName+
" age="+age+"]"
def doSomething = // uh.... what?
}
這帶來了一個問題：Person 的用途究竟是什麼？有些 Person 繪畫，有些唱歌，有些編寫代碼，有些玩視頻游戲，有些什麼也不做（問問十幾歲青少年的父母）。因此，我會為 Person 創建 子類，而不是嘗試去將這些活動直接整合到 Person 本身之中，如清單 4 所示：
清單 4. 這個人做的事情很少
// This is Scala
class Person(val firstName:String, val lastName:String, val age:Int)
{
override def toString = "[Person: firstName="+firstName+" lastName="+lastName+
" age="+age+"]"
def doSomething = // uh.... what?
}
class Student(firstName:String, lastName:String, age:Int)
extends Person(firstName, lastName, age)
{
def doSomething =
{
System.out.println("I'm studying hard, Ma, I swear! (Pass the beer, guys!)")
}
}
當嘗試編譯代碼時，我發現無法編譯。這是因為 Person.doSomething 方法的定義無法工作；這個方法需要一個完整的主體（或許可拋出異常來表示它應在繼承類中被覆蓋），或者不需要主體，類似於 Java 代碼中抽象方法的工作方式。我在清單 5 中嘗試使用抽象的方法：
清單 5. 抽象類 Person
// This is Scala
abstract class Person(val firstName:String, val lastName:String, val age:Int)
{
override def toString = "[Person: firstName="+firstName+" lastName="+lastName+
" age="+age+"]"
def doSomething; // note the semicolon, which is still optional
// but stylistically I like having it here
}
class Student(firstName:String, lastName:String, age:Int)
extends Person(firstName, lastName, age)
{
def doSomething =
{
System.out.println("I'm studying hard, Ma, I swear! (Pass the beer, guys!)")
}
}
請注意，我如何使用 abstract 關鍵字裝飾 Person 類。abstract 為編譯器指出，是的，這個類應該是抽象的。在這方面，Scala 與 Java 語言沒有區別。
對象，遇到函數
由於 Scala 融合了對象和函數語言風格，我實際上建模了 Person（如上所述），但並未創建子類型。這有些古怪，但強調了 Scala 對於這兩種設計風格的整合，以及隨之而來的有趣理念。
回憶 前幾期文章，Scala 將函數作為值處理，就像處理語言中的其他值一樣，例如 Int、Float 或 Double。在建模 Person 時，我可以利用這一點來獲得 doSomething，不僅將其作為一種繼承類中覆蓋的方法，還將其作為可調用、替換、擴展的 函數值。清單 6 展示了這種方法：
清單 6. 努力工作的人
// This is Scala
class Person(val firstName:String, val lastName:String, val age:Int)
{
var doSomething : (Person) => Unit =
(p:Person) => System.out.println("I'm " + p + " and I don't do anything yet!");
def work() =
doSomething(this)
override def toString = "[Person: firstName="+firstName+" lastName="+lastName+
" age="+age+"]"
}
object App
{
def main(args : Array[String]) =
{
val bindi = new Person("Tabinda", "Khan", 38)
System.out.println(bindi)
bindi.work()
bindi.doSomething =
(p:Person) => System.out.println("I edit textbooks")
bindi.work()
bindi.doSomething =
(p:Person) => System.out.println("I write HTML books")
bindi.work()
}
}
將函數作為第一建模工具是 Ruby、Groovy 和 ECMAScript（也就是 JavaScript）等動態語言以及許多函數語言的常用技巧。盡管其他語言也可以用函數作為建模工具，（C++ 通過函數指針和/或成員函數指針實現，Java 代碼中通過接口引用的匿名內部類實現），但所需的工作比 Scala（以及 Ruby、Groovy、ECMAScript 和其他語言）多得多。這是函數語言使用的 “高階函數” 概念的擴展。（關於高階函數的更多內容，請參見 參考資料。）
多虧 Scala 將函數視為值，這樣您就可以在運行時需要切換功能的時候利用函數值。可將這種方法視為角色模式 —— Gang of Four 戰略模式的一種變體，在這種模式中，對象角色（例如 Person 的當前就職狀態）作為運行時值得到了更好的表現，比靜態類型的層次結構更好。
層次結構上層的構造函數
回憶一下編寫 Java 代碼的日子，有時繼承類需要從構造函數傳遞參數至基類構造函數，從而使基類字段能夠初始化。在 Scala 中，由於主構造函數出現在類聲明中，不再是類的 “傳統” 成員，因而將參數傳遞到基類將成為一個全新維度的問題。
在 Scala 中，主構造函數的參數在 class 行傳遞，但您也可以為這些參數使用 val 修飾符，以便在類本身上輕松引入讀值器（對於 var，則為寫值器）。
因此，清單 5 中的 Scala 類 Person 轉變為清單 7 中的 Java 類，使用 javap 查看：
清單 7. 請翻譯一下
// This is javap
C:\Projects\scala-inheritance\code>javap -classpath classes Person
Compiled from "person.scala"
public abstract class Person extends java.lang.Object implements scala.ScalaObje
ct{
public Person(java.lang.String, java.lang.String, int);
public java.lang.String toString();
public abstract void doSomething();
public int age();
public java.lang.String lastName();
public java.lang.String firstName();
public int $tag();
}
JVM 的基本規則依然有效：Person 的繼承類在構造時向基類傳遞某些內容，而不管語言強調的是什麼。（實際上，這並非完全 正確，但在語言嘗試規避此規則時，JVM 會表現失常，因此大多數語言仍然堅持通過某種方法為其提供支持。）當然，Scala 需要堅守此規則，因為它不僅需要保持 JVM 正常運作，而且還要保持 Java 基類正常運作。這也就是說，無論如何，Scala 必須實現一種語法，允許繼承類調用基類，同時保留允許我們在基類上引入讀值器和寫值器的語法。
為了將此放到更具體的上下文中，假設我通過以下方式編寫了 清單 5 中的 Student 類：
清單 8. 壞學生！
// This is Scala
// This WILL NOT compile
class Student(val firstName:String, val lastName:String, val age:Int)
extends Person(firstName, lastName, age)
{
def doSomething =
{
System.out.println("I'm studying hard, Ma, I swear! (Pass the beer, guys!)")
}
}
本例中的編譯器將運行很長一段時間，因為我嘗試為 Student 類引入一組新方法（firstName、lastName 和 age）。這些方法將與 Person 類上名稱類似的方法彼此沖突，Scala 編譯器不一定了解我是否正在嘗試覆蓋基類方法（這很糟糕，因為我可以在這些基類方法後隱藏實現和字段），或者引入相同名稱的新方法（這也很糟糕，因為我可以在這些基類方法後隱藏實現和字段）。簡而言之，您將看到如何成功覆蓋來自基類的方法，但那並不是我們目前要追求的目標。
您還應注意到，在 Scala 中，Person 構造函數的參數不必一對一地與傳遞給 Student 的參數聯系起來；這裡的規則實際上與 Java 構造函數的規則完全相同。我們這樣做只是為了便於閱讀。同樣，Student 可要求額外的構造函數參數，與在 Java 語言中一樣，如清單 9 所示：
清單 9. 苛求的學生！
// This is Scala
class Student(firstName:String, lastName:String, age:Int, val subject:String)
extends Person(firstName, lastName, age)
{
def doSomething =
{
System.out.println("I'm studying hard, Ma, I swear! (Pass the beer, guys!)")
}
}
您又一次看到了 Scala 代碼與 Java 代碼有多麼的相似，至少涉及繼承和類關系時是這樣。
語法差異
至此，您可能會對語法的細節感到迷惑。畢竟 Scala 並未像 Java 語言那樣將字段與方法區分開來。這實際上是一項深思熟慮的設計決策，允許 Scala 程序員輕而易舉地向使用基類的用戶 “隱藏” 字段和方法之間的差異。考慮清單 10：
清單 10. 我是什麼？
// This is Scala
abstract class Person(val firstName:String, val lastName:String, val age:Int)
{
def doSomething
def weight : Int
override def toString = "[Person: firstName="+firstName+" lastName="+lastName+
" age="+age+"]"
}
class Student(firstName:String, lastName:String, age:Int, val subject:String)
extends Person(firstName, lastName, age)
{
def weight : Int =
age // students are notoriously skinny
def doSomething =
{
System.out.println("I'm studying hard, Ma, I swear! (Pass the beer, guys!)")
}
}
class Employee(firstName:String, lastName:String, age:Int)
extends Person(firstName, lastName, age)
{
val weight : Int = age * 4 // Employees are not skinny at all
def doSomething =
{
System.out.println("I'm working hard, hon, I swear! (Pass the beer, guys!)")
}
}
注意查看如何定義 weight 使其不帶有任何參數並返回 Int。這是 “無參數方法”。因為它看上去與 Java 語言中的 “專有” 方法極其相似，Scala 實際上允許將 weight 定義為一種方法（如 Student 中所示），也允許將其定義為字段/存取器（如 Employee 中所示）。這種句法決策使您在抽象類繼承的實現方面有一定的靈活性。請注意，在 Java 中，即便是在同一個類中，只有通過 get/set 方法來訪問各字段時，才能獲得類似的靈活性。不知道判斷正確與否，但我認為只有少數 Java 程序員會用這種方式編寫代碼，因此不經常使用靈活性。此外，Scala 的方法可像處理公共成員一樣輕松地處理隱藏/私有成員。
從 @Override 到 override
繼承類經常需要更改在其某個基類內定義的方法的行為；在 Java 代碼中，我們通過為繼承類添加相同名稱、相同簽名的新方法來處理這個問題。這種方法的缺點在於簽名錄入的錯誤或含糊不清可能會導致沒有征兆的故障，這也就意味著代碼可以編譯，但在運行時無法正確完成操作。
為解決這個問題，Java 5 編譯器引入了 @Override 注釋。@Override 驗證引入繼承類的方法實際上已經覆蓋了基類方法。在 Scala 中，override 已經成為語言的一部分，幾乎可以忘記它會生成編譯器錯誤。因而，繼承 toString() 方法應如清單 11 所示：
清單 11. 這是繼承的結果
// This is Scala
class Student(firstName:String, lastName:String, age:Int, val subject:String)
extends Person(firstName, lastName, age)
{
def weight : Int =
age // students are notoriously skinny
def doSomething =
{
System.out.println("I'm studying hard, Ma, I swear! (Pass the beer, guys!)")
}
override def toString = "[Student: firstName="+firstName+
" lastName="+lastName+" age="+age+
" subject="+subject+"]"
}
非常簡單明了。
敲定
當然，允許繼承覆蓋的反面就是采取措施防止它：基類需要禁止子類更改其基類行為，或禁止任何類型的繼承類。在 Java 語言中，我們通過為方法應用修飾符 final 來實現這一點，確保它不會被覆蓋。此外，也可以為類整體應用 final，防止繼承。實現層次結構在 Scala 中的效果是相同的：我們可以向方法應用 final 來防止子類覆蓋它，也可應用於類聲明本身來防止繼承。
牢記，所有這些關於 abstract、final 和 override 的討論都同樣適用於 “名字很有趣的方法”（Java 或 C# 或 C++ 程序員可能會這樣稱呼運算符），與應用於常規名稱方法的效果相同。因此，我們常常會定義一個基類或特征，為數學函數設定某些預期（可以稱之為 “Mathable”），這些函數定義抽象成員函數 “+”、“-”、“*” 和 “/”，另外還有其他一些應該支持的數學運算，例如 pow 或 abs。隨後，其他程序員可創建其他類型 — 可能是一個 Matrix 類，實現或擴展 “Mathable”，定義一些成員，看上去就像 Scala 以開箱即用的方式提供的內置算術類型。
差別在於……
如果 Scala 能夠如此輕松地映射到 Java 繼承模型（就像本文至此您看到的那樣），就應該能夠從 Java 語言繼承 Scala 類，或反之。實際上，這必須 可行，因為 Scala 與其他編譯為 Java 字節碼的語言相似，必須生成繼承自 java.lang.Object 的對象。請注意，Scala 類可能也要繼承自其他內容，例如特征，因此實際繼承的解析和代碼生成的工作方式可能有所不同，但最終我們必須能夠以某種形式繼承 Java 基類。（切記，特征類似於有行為的接口，Scala 編譯器將特征分成接口並將實現推入特征編譯的目標類中，通過這種方式來使之運作。）
但結果表明，Scala 的類型層次結構與 Java 語言中的對應結構略有不同；從技術上來講，所有 Scala 類繼承的基類（包括 Int、Float、Double 和其他數字類型）都是 scala.Any 類型，這定義了一組核心方法，可在 Scala 內的任意類型上使用：==、!=、equals、hashCode、toString、isInstanceOf 和 asInstanceOf，大多數方法通過名稱即可輕松理解。在這裡，Scala 劃分為兩大分支，“原語類型” 繼承自 scala.AnyVal；“類類型” 繼承自 scala.AnyRe。（scala.ScalaObject 又繼承自 scala.AnyRef。）
通常，這並不是您要直接去操心的方面，但在考慮跨兩種語言的繼承時，可能會帶來某些非常有趣的副作用。例如，考慮清單 12 中的 ScalaJavaPerson：
清單 12. 混合！
// This is Scala
class ScalaJavaPerson(firstName:String, lastName:String, age:Int)
extends JavaPerson(firstName, lastName, age)
{
val weight : Int = age * 2 // Who knows what Scala/Java people weigh?
override def toString = "[SJPerson: firstName="+firstName+
" lastName="+lastName+" age="+age+"]"
}
……它繼承自 JavaPerson：
清單 13. 看起來是否眼熟？
// This is Java
public class JavaPerson
{
public JavaPerson(String firstName, String lastName, int age)
{
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
public String getFirstName()
{
return this.firstName;
}
public void setFirstName(String value)
{
this.firstName = value;
}
public String getLastName()
{
return this.lastName;
}
public void setLastName(String value)
{
this.lastName = value;
}
public int getAge()
{
return this.age;
}
public void setAge(int value)
{
this.age = value;
}
public String toString()
{
return "[Person: firstName" + firstName + " lastName:" + lastName +
" age:" + age + " ]";
}
private String firstName;
private String lastName;
private int age;
}
在編譯 ScalaJavaPerson 時，它將照常擴展 JavaPerson，但按照 Scala 的要求，它還會實現 ScalaObject 接口。並照例支持繼承自 JavaPerson 的方法，因為 ScalaJavaPerson 是一種 Scala 類型，我們可以期望它支持 Any 引用的指派，根據 Scala 的規則：
清單 14. 使用 ScalaJavaPerson
// This is Scala
val richard = new ScalaJavaPerson("Richard", "Campbell", 45)
System.out.println(richard)
val host : Any = richard
System.out.println(host)
但在 Scala 中創建 JavaPerson 並將其指派給 Any 引用時會發生什麼？
清單 15. 使用 JavaPerson
// This is Scala
val carl = new JavaPerson("Carl", "Franklin", 35)
System.out.println(carl)
val host2 : Any = carl
System.out.println(host2)
結果顯示，這段代碼如期編譯並運行，因為 Scala 能確保 JavaPerson “做正確的事情”，這要歸功於 Any 類型與 java.lang.Object 類型的相似性。實際上，幾乎可以說，所有擴展 java.lang.Object 的內容都支持存儲到 Any 引用之中。（存在一些極端情況，我聽說過，但我自己還從未遇到過這樣的極端情況。）
最終結果？出於實踐的目的，我們可以跨 Java 語言和 Scala 混搭繼承，而無需過分擔心。（最大的麻煩將是試圖了解如何覆蓋 “名字很有趣的 Scala 方法”，例如 ^=!# 或類似方法。）
結束語
在本月的文章中，我為您介紹了 Scala 代碼和 Java 代碼之間的高度相似性意味著 Java 開發人員可以輕松理解並使用 Scala 的繼承模型。方法覆蓋的工作方式相同，成員可見性的工作方式相同，還有更多相同的地方。對於 Scala 中的所有功能，繼承或許與 Java 開發中的對應部分最為相似。惟一需要技巧的部分就是 Scala 語法，這有著明顯的差異。
習慣兩種語言中繼承方法的相似之處和細微的差異，您就可以輕松編寫您自己的 Java 程序的 Scala 實現。例如，考慮流行的 Java 基類和框架的 Scala 實現，如 JUnit、Servlets、Swing 或 SWT。實際上，Scala 團隊已經提供了一個 Swing 應用程序，名為 OOPScala（參見 參考資料），它使用 JTable，通過相當少的幾行代碼（數量級遠遠低於傳統 Java 的對應實現）提供了簡單的電子表格功能。
因此，如果您想知道如何在您的生產代碼中應用 Scala，就應該准備好邁出探索的第一步。考慮在 Scala 中編寫下一個程序的一小部分。正如您在這期文章中所了解到的那樣，從恰當的基類繼承，采用與 Java 程序中相同的方式提供覆蓋，您就不會遇到任何麻煩。
