從Java走進(jìn)Scala:當(dāng)繼承中的對象遇到函數(shù)
近十幾年來，面向?qū)ο笳Z言設(shè)計(jì)的要素一直是繼承的核心。不支持繼承的語言（如 Visual Basic）被嘲諷是 “玩具語言” ，不適合真正的工作。與此同時(shí)，支持繼承的語言所采用的支持方法五花八門，導(dǎo)致了許多爭論。多重繼承是否真的必不可少（就像 C++ 的創(chuàng)作者認(rèn)定的那樣），它是否不必要而丑陋的（就像 C# 和 Java 的創(chuàng)作者堅(jiān)信的那樣）？Ruby 和 Scala 是兩種較新的語言，采取了多重繼承的這種方法 — 正如我在上期介紹 Scala 的特征時(shí)所討論的那樣。
與所有 杰出的語言一樣，Scala 也支持實(shí)現(xiàn)繼承。在 Java 語言中，單一實(shí)現(xiàn)繼承模型允許您擴(kuò)展基類，添加新方法和字段等。盡管存在某些句法變更，Scala 的實(shí)現(xiàn)繼承依然類似于 Java 語言中的實(shí)現(xiàn)。不同的是 Scala 融合了對象和函數(shù)語言設(shè)計(jì)，這非常值得我們在本期文章中進(jìn)行討論。
普通 Scala 對象
與本系列之前的文章類似，我將使用 Person 類作為起點(diǎn)，探索 Scala 的繼承系統(tǒng)。清單 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 是一個(gè)非常簡單的 POSO（普通 Scala 對象，Plain Old Scala Object），具有三個(gè)只讀字段。您可能會(huì)想起，要使這些字段可以讀寫，只需將主構(gòu)造函數(shù)聲明中的 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)
- }
- }
這算不上什么令人驚訝的代碼，但給我們提供了一個(gè)起點(diǎn)。
Scala 中的抽象方法
隨著該系統(tǒng)的發(fā)展，越來越明顯地意識到 Person 類缺乏一個(gè)成為 Person 的重要部分，這個(gè)部分是做些事情 的行為。許多人都會(huì)根據(jù)我們在生活中的作為來定義自己，而不是根據(jù)現(xiàn)有和占用的空間。因此，我會(huì)添加一個(gè)新方法，如清單 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?
- }
這帶來了一個(gè)問題：Person 的用途究竟是什么？有些 Person 繪畫，有些唱歌，有些編寫代碼，有些玩視頻游戲，有些什么也不做（問問十幾歲青少年的父母）。因此，我會(huì)為 Person 創(chuàng)建 子類，而不是嘗試去將這些活動(dòng)直接整合到 Person 本身之中，如清單 4 所示：
清單 4. 這個(gè)人做的事情很少
- // 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!)")
- }
- }
當(dāng)嘗試編譯代碼時(shí)，我發(fā)現(xiàn)無法編譯。這是因?yàn)?Person.doSomething 方法的定義無法工作；這個(gè)方法需要一個(gè)完整的主體（或許可拋出異常來表示它應(yīng)在繼承類中被覆蓋），或者不需要主體，類似于 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 關(guān)鍵字裝飾 Person 類。abstract 為編譯器指出，是的，這個(gè)類應(yīng)該是抽象的。在這方面，Scala 與 Java 語言沒有區(qū)別。
#p#
對象，遇到函數(shù)
由于 Scala 融合了對象和函數(shù)語言風(fēng)格，我實(shí)際上建模了 Person（如上所述），但并未創(chuàng)建子類型。這有些古怪，但強(qiáng)調(diào)了 Scala 對于這兩種設(shè)計(jì)風(fēng)格的整合，以及隨之而來的有趣理念。
回憶 前幾期文章，Scala 將函數(shù)作為值處理，就像處理語言中的其他值一樣，例如 Int、Float 或 Double。在建模 Person 時(shí)，我可以利用這一點(diǎn)來獲得 doSomething，不僅將其作為一種繼承類中覆蓋的方法，還將其作為可調(diào)用、替換、擴(kuò)展的 函數(shù)值。清單 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()
- }
- }
將函數(shù)作為***建模工具是 Ruby、Groovy 和 ECMAScript（也就是 JavaScript）等動(dòng)態(tài)語言以及許多函數(shù)語言的常用技巧。盡管其他語言也可以用函數(shù)作為建模工具，（C++ 通過函數(shù)指針和/或成員函數(shù)指針實(shí)現(xiàn)，Java 代碼中通過接口引用的匿名內(nèi)部類實(shí)現(xiàn)），但所需的工作比 Scala（以及 Ruby、Groovy、ECMAScript 和其他語言）多得多。這是函數(shù)語言使用的 “高階函數(shù)” 概念的擴(kuò)展。（關(guān)于高階函數(shù)的更多內(nèi)容，請參見 參考資料。）
多虧 Scala 將函數(shù)視為值，這樣您就可以在運(yùn)行時(shí)需要切換功能的時(shí)候利用函數(shù)值?？蓪⑦@種方法視為角色模式 —— Gang of Four 戰(zhàn)略模式的一種變體，在這種模式中，對象角色（例如 Person 的當(dāng)前就職狀態(tài)）作為運(yùn)行時(shí)值得到了更好的表現(xiàn)，比靜態(tài)類型的層次結(jié)構(gòu)更好。
層次結(jié)構(gòu)上層的構(gòu)造函數(shù)
回憶一下編寫 Java 代碼的日子，有時(shí)繼承類需要從構(gòu)造函數(shù)傳遞參數(shù)至基類構(gòu)造函數(shù)，從而使基類字段能夠初始化。在 Scala 中，由于主構(gòu)造函數(shù)出現(xiàn)在類聲明中，不再是類的 “傳統(tǒng)” 成員，因而將參數(shù)傳遞到基類將成為一個(gè)全新維度的問題。
在 Scala 中，主構(gòu)造函數(shù)的參數(shù)在 class 行傳遞，但您也可以為這些參數(shù)使用 val 修飾符，以便在類本身上輕松引入讀值器（對于 var，則為寫值器）。
因此，清單 5 中的 Scala 類 Person 轉(zhuǎn)變?yōu)榍鍐?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 的基本規(guī)則依然有效：Person 的繼承類在構(gòu)造時(shí)向基類傳遞某些內(nèi)容，而不管語言強(qiáng)調(diào)的是什么。（實(shí)際上，這并非完全 正確，但在語言嘗試規(guī)避此規(guī)則時(shí)，JVM 會(huì)表現(xiàn)失常，因此大多數(shù)語言仍然堅(jiān)持通過某種方法為其提供支持。）當(dāng)然，Scala 需要堅(jiān)守此規(guī)則，因?yàn)樗粌H需要保持 JVM 正常運(yùn)作，而且還要保持 Java 基類正常運(yùn)作。這也就是說，無論如何，Scala 必須實(shí)現(xiàn)一種語法，允許繼承類調(diào)用基類，同時(shí)保留允許我們在基類上引入讀值器和寫值器的語法。
為了將此放到更具體的上下文中，假設(shè)我通過以下方式編寫了 清單 5 中的 Student 類：
清單 8. 壞學(xué)生！
- // 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!)")
- }
- }
本例中的編譯器將運(yùn)行很長一段時(shí)間，因?yàn)槲覈L試為 Student 類引入一組新方法（firstName、lastName 和 age）。這些方法將與 Person 類上名稱類似的方法彼此沖突，Scala 編譯器不一定了解我是否正在嘗試覆蓋基類方法（這很糟糕，因?yàn)槲铱梢栽谶@些基類方法后隱藏實(shí)現(xiàn)和字段），或者引入相同名稱的新方法（這也很糟糕，因?yàn)槲铱梢栽谶@些基類方法后隱藏實(shí)現(xiàn)和字段）。簡而言之，您將看到如何成功覆蓋來自基類的方法，但那并不是我們目前要追求的目標(biāo)。
您還應(yīng)注意到，在 Scala 中，Person 構(gòu)造函數(shù)的參數(shù)不必一對一地與傳遞給 Student 的參數(shù)聯(lián)系起來；這里的規(guī)則實(shí)際上與 Java 構(gòu)造函數(shù)的規(guī)則完全相同。我們這樣做只是為了便于閱讀。同樣，Student 可要求額外的構(gòu)造函數(shù)參數(shù)，與在 Java 語言中一樣，如清單 9 所示：
清單 9. 苛求的學(xué)生！
- // 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 代碼有多么的相似，至少涉及繼承和類關(guān)系時(shí)是這樣。
語法差異
至此，您可能會(huì)對語法的細(xì)節(jié)感到迷惑。畢竟 Scala 并未像 Java 語言那樣將字段與方法區(qū)分開來。這實(shí)際上是一項(xiàng)深思熟慮的設(shè)計(jì)決策，允許 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 使其不帶有任何參數(shù)并返回 Int。這是 “無參數(shù)方法”。因?yàn)樗瓷先ヅc Java 語言中的 “專有” 方法極其相似，Scala 實(shí)際上允許將 weight 定義為一種方法（如 Student 中所示），也允許將其定義為字段/存取器（如 Employee 中所示）。這種句法決策使您在抽象類繼承的實(shí)現(xiàn)方面有一定的靈活性。請注意，在 Java 中，即便是在同一個(gè)類中，只有通過 get/set 方法來訪問各字段時(shí)，才能獲得類似的靈活性。不知道判斷正確與否，但我認(rèn)為只有少數(shù) Java 程序員會(huì)用這種方式編寫代碼，因此不經(jīng)常使用靈活性。此外，Scala 的方法可像處理公共成員一樣輕松地處理隱藏/私有成員。
#p#
從 @Override 到 override
繼承類經(jīng)常需要更改在其某個(gè)基類內(nèi)定義的方法的行為；在 Java 代碼中，我們通過為繼承類添加相同名稱、相同簽名的新方法來處理這個(gè)問題。這種方法的缺點(diǎn)在于簽名錄入的錯(cuò)誤或含糊不清可能會(huì)導(dǎo)致沒有征兆的故障，這也就意味著代碼可以編譯，但在運(yùn)行時(shí)無法正確完成操作。
為解決這個(gè)問題，Java 5 編譯器引入了 @Override 注釋。@Override 驗(yàn)證引入繼承類的方法實(shí)際上已經(jīng)覆蓋了基類方法。在 Scala 中，override 已經(jīng)成為語言的一部分，幾乎可以忘記它會(huì)生成編譯器錯(cuò)誤。因而，繼承 toString() 方法應(yīng)如清單 11 所示：
清單 11. 這是繼承的結(jié)果
- // 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+"]"
- }
非常簡單明了。
敲定
當(dāng)然，允許繼承覆蓋的反面就是采取措施防止它：基類需要禁止子類更改其基類行為，或禁止任何類型的繼承類。在 Java 語言中，我們通過為方法應(yīng)用修飾符 final 來實(shí)現(xiàn)這一點(diǎn)，確保它不會(huì)被覆蓋。此外，也可以為類整體應(yīng)用 final，防止繼承。實(shí)現(xiàn)層次結(jié)構(gòu)在 Scala 中的效果是相同的：我們可以向方法應(yīng)用 final 來防止子類覆蓋它，也可應(yīng)用于類聲明本身來防止繼承。
牢記，所有這些關(guān)于 abstract、final 和 override 的討論都同樣適用于 “名字很有趣的方法”（Java 或 C# 或 C++ 程序員可能會(huì)這樣稱呼運(yùn)算符），與應(yīng)用于常規(guī)名稱方法的效果相同。因此，我們常常會(huì)定義一個(gè)基類或特征，為數(shù)學(xué)函數(shù)設(shè)定某些預(yù)期（可以稱之為 “Mathable”），這些函數(shù)定義抽象成員函數(shù) “+”、“-”、“*” 和 “/”，另外還有其他一些應(yīng)該支持的數(shù)學(xué)運(yùn)算，例如 pow 或 abs。隨后，其他程序員可創(chuàng)建其他類型 — 可能是一個(gè) Matrix 類，實(shí)現(xiàn)或擴(kuò)展 “Mathable”，定義一些成員，看上去就像 Scala 以開箱即用的方式提供的內(nèi)置算術(shù)類型。
差別在于……
如果 Scala 能夠如此輕松地映射到 Java 繼承模型（就像本文至此您看到的那樣），就應(yīng)該能夠從 Java 語言繼承 Scala 類，或反之。實(shí)際上，這必須 可行，因?yàn)?Scala 與其他編譯為 Java 字節(jié)碼的語言相似，必須生成繼承自 java.lang.Object 的對象。請注意，Scala 類可能也要繼承自其他內(nèi)容，例如特征，因此實(shí)際繼承的解析和代碼生成的工作方式可能有所不同，但最終我們必須能夠以某種形式繼承 Java 基類。（切記，特征類似于有行為的接口，Scala 編譯器將特征分成接口并將實(shí)現(xiàn)推入特征編譯的目標(biāo)類中，通過這種方式來使之運(yùn)作。）
但結(jié)果表明，Scala 的類型層次結(jié)構(gòu)與 Java 語言中的對應(yīng)結(jié)構(gòu)略有不同；從技術(shù)上來講，所有 Scala 類繼承的基類（包括 Int、Float、Double 和其他數(shù)字類型）都是 scala.Any 類型，這定義了一組核心方法，可在 Scala 內(nèi)的任意類型上使用：==、!=、equals、hashCode、toString、isInstanceOf 和 asInstanceOf，大多數(shù)方法通過名稱即可輕松理解。在這里，Scala 劃分為兩大分支，“原語類型” 繼承自 scala.AnyVal；“類類型” 繼承自 scala.AnyRe。（scala.ScalaObject 又繼承自 scala.AnyRef。）
通常，這并不是您要直接去操心的方面，但在考慮跨兩種語言的繼承時(shí)，可能會(huì)帶來某些非常有趣的副作用。例如，考慮清單 12 中的 ScalaJavaPerson：
清單 12. 混合！
- // This is Scala
- ass 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 時(shí)，它將照常擴(kuò)展 JavaPerson，但按照 Scala 的要求，它還會(huì)實(shí)現(xiàn) ScalaObject 接口。并照例支持繼承自 JavaPerson 的方法，因?yàn)?ScalaJavaPerson 是一種 Scala 類型，我們可以期望它支持 Any 引用的指派，根據(jù) Scala 的規(guī)則：
清單 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 中創(chuàng)建 JavaPerson 并將其指派給 Any 引用時(shí)會(huì)發(fā)生什么？
清單 15. 使用 JavaPerson
- // This is Scala
- val carl = new JavaPerson("Carl", "Franklin", 35)
- System.out.println(carl)
- val host2 : Any = carl
- System.out.println(host2)
結(jié)果顯示，這段代碼如期編譯并運(yùn)行，因?yàn)?Scala 能確保 JavaPerson “做正確的事情”，這要?dú)w功于 Any 類型與 java.lang.Object 類型的相似性。實(shí)際上，幾乎可以說，所有擴(kuò)展 java.lang.Object 的內(nèi)容都支持存儲(chǔ)到 Any 引用之中。（存在一些極端情況，我聽說過，但我自己還從未遇到過這樣的極端情況。）
最終結(jié)果？出于實(shí)踐的目的，我們可以跨 Java 語言和 Scala 混搭繼承，而無需過分擔(dān)心。（***的麻煩將是試圖了解如何覆蓋 “名字很有趣的 Scala 方法”，例如 ^=!# 或類似方法。）
結(jié)束語
在本月的文章中，我為您介紹了 Scala 代碼和 Java 代碼之間的高度相似性意味著 Java 開發(fā)人員可以輕松理解并使用 Scala 的繼承模型。方法覆蓋的工作方式相同，成員可見性的工作方式相同，還有更多相同的地方。對于 Scala 中的所有功能，繼承或許與 Java 開發(fā)中的對應(yīng)部分最為相似。惟一需要技巧的部分就是 Scala 語法，這有著明顯的差異。
習(xí)慣兩種語言中繼承方法的相似之處和細(xì)微的差異，您就可以輕松編寫您自己的 Java 程序的 Scala 實(shí)現(xiàn)。例如，考慮流行的 Java 基類和框架的 Scala 實(shí)現(xiàn)，如 JUnit、Servlets、Swing 或 SWT。實(shí)際上，Scala 團(tuán)隊(duì)已經(jīng)提供了一個(gè) Swing 應(yīng)用程序，名為 OOPScala（參見 參考資料），它使用 JTable，通過相當(dāng)少的幾行代碼（數(shù)量級遠(yuǎn)遠(yuǎn)低于傳統(tǒng) Java 的對應(yīng)實(shí)現(xiàn)）提供了簡單的電子表格功能。
因此，如果您想知道如何在您的生產(chǎn)代碼中應(yīng)用 Scala，就應(yīng)該準(zhǔn)備好邁出探索的***步。考慮在 Scala 中編寫下一個(gè)程序的一小部分。正如您在這期文章中所了解到的那樣，從恰當(dāng)?shù)幕惱^承，采用與 Java 程序中相同的方式提供覆蓋，您就不會(huì)遇到任何麻煩。
【相關(guān)閱讀】
