近日，Scala的創(chuàng)始人發(fā)表了“Scala is for good programmers（Scala語言是給專家級程序員的）”這樣的言論！Scala在現(xiàn)在這個(gè)階段并不需要適合一般的Java程序員。要吸引的是一些專家級的程序員——優(yōu)秀的程序員。目標(biāo)是使他們工作起來比使用Java更有效率。只有會(huì)出現(xiàn)足夠多的教育示范材料和足夠好的開發(fā)工具時(shí)，Scala對廣大的普通開發(fā)人員才具有吸引力。但是Scala語言什么呢？

《Scala編程指南》系列文章將會(huì)詳細(xì)介紹Scala語言。本文為《Scala編程指南》系列的第四章，將介紹Traits功能。

Traits 介紹

在我們深入面向?qū)ο缶幊讨?，我們還需要了解Scala 一個(gè)特性：Traits。要了解這個(gè)功能需要一點(diǎn)歷史知識(shí)。

在Java 中，一個(gè)類可以實(shí)現(xiàn)任意數(shù)量的接口。這個(gè)模型在聲明一個(gè)類實(shí)現(xiàn)多個(gè)抽象的時(shí)候非常有用。不幸的是，它也有一個(gè)主要缺點(diǎn)。

對于許多接口，大多數(shù)功能都可以用對于所有使用這個(gè)接口的類都有效的“樣板”代碼來實(shí)現(xiàn)。Java 沒有提供一個(gè)內(nèi)置機(jī)制來定義和使用這些可重用代碼。相反的，Java 程序員必須使用一個(gè)特別的轉(zhuǎn)換來重用一個(gè)已知接口的實(shí)現(xiàn)。在最壞的情況下，程序員必須復(fù)制粘貼同樣的代碼到不同的類中去。

通常，一個(gè)接口的實(shí)現(xiàn)擁有和該實(shí)例的其它成員無關(guān)（正交）的成員。術(shù)語mixin （混合）通常被用來指實(shí)例中這些專注的，潛在可被重用的，并且可以獨(dú)立維護(hù)的代碼。

來看一下下面這個(gè)圖形用戶接口的按鈕的代碼，它對單擊事件使用了回調(diào)。

// code-examples/Traits/ui/button-callbacks.scala  
package ui  
class ButtonWithCallbacks(val label: String,  
    val clickedCallbacks: List[() => Unit]) extends Widget {  
 
  require(clickedCallbacks != null, "Callback list can't be null!")  
 
  def this(label: String, clickedCallback: () => Unit) =  
    this(label, List(clickedCallback))  
 
  def this(label: String) = {  
    this(label, Nil)  
    println("Warning: button has no click callbacks!")  
  }  
 
  def click() = {  
    // ... logic to give the appearance of clicking a physical button ...  
    clickedCallbacks.foreach(f => f())  
  }  
}  

這里發(fā)生了很多事情。主構(gòu)造函數(shù)接受一個(gè)label（標(biāo)簽）參數(shù)和一個(gè)callbacks（回調(diào)）的list（列表），這些回調(diào)函數(shù)會(huì)在按鈕的click 方法被調(diào)用時(shí)被調(diào)用。我們會(huì)在《第5章 - Scala 基礎(chǔ)面向?qū)ο缶幊獭分衼硖剿鬟@個(gè)類的更多細(xì)節(jié)?，F(xiàn)在，我們希望專注在一個(gè)特別的問題上。ButtonWithCallbacks 不僅處理按鈕的一些本質(zhì)行為（比如單擊），它同時(shí)還通過調(diào)用回調(diào)函數(shù)處理單擊事件的通知。這違反了單職原則[Martin2003]，這是分隔職能的一種設(shè)計(jì)方法。我們可以把按鈕類的邏輯從回調(diào)邏輯中分離出來，這樣每一個(gè)邏輯組件變得更加簡單，更模塊化，更可重用化。這個(gè)回調(diào)邏輯就是mixin 的一個(gè)不錯(cuò)例子。

這樣的分離在Java 中很難做，即使我們定義了具有回調(diào)行為的接口，我們?nèi)匀恍枰陬愔屑蓪?shí)現(xiàn)代碼，降低模塊性。唯一的其它方法則是使用特定的工具比如面向方面編程（Aspect-Oriented Programming，AOP，參見[AOSD]），一個(gè)實(shí)現(xiàn)是AspectJ，Java 的一個(gè)擴(kuò)展。AOP 主要被設(shè)計(jì)用來分離在應(yīng)用程序中重復(fù)出現(xiàn)的普遍問題的實(shí)現(xiàn)。它設(shè)法模塊化這些關(guān)鍵點(diǎn)，但是也允許設(shè)計(jì)良好的和其它關(guān)鍵點(diǎn)行為的“混合”，包括應(yīng)用程序的核心域邏輯，不管是在編譯時(shí)還是運(yùn)行時(shí)。

作為混合體的Traits

Scala 提供了完整的混合（mixin）解決方案，稱為Traits。在我們的例子里，我們可以定義回調(diào)的抽象為一個(gè)Trait，就像一個(gè)Java 接口一樣，但是我們可以實(shí)現(xiàn)這些Trait （或者繼承的Trait）的抽象。我們可以定義混合了Trait 的類，大致上很像實(shí)現(xiàn)Java 的一個(gè)接口。不過，在Scala 你甚至可以在我們創(chuàng)建實(shí)例的時(shí)候混合Traits。也就是說，我們不必首先聲明一個(gè)混合了所有我們所需要的Trait 的類。所以，Scala Traits 在保留分離關(guān)鍵點(diǎn)的同時(shí)給了我們按需整合行為的能力。

如果你來自于Java 編程世界，你可以認(rèn)為Traits 是有選擇地實(shí)現(xiàn)了的接口。其它語言提供了類似Trait 的結(jié)構(gòu)，比如Ruby 中的模塊（modules）。

讓我們對按鈕的邏輯來使用Trait，從而分離回調(diào)的處理。我們會(huì)推廣一下我們的實(shí)現(xiàn)。回調(diào)其實(shí)是觀察者模式[GOF1995] 的一個(gè)特例。所以，讓我們創(chuàng)建一個(gè)Trait 來實(shí)現(xiàn)這個(gè)模式，然后用它來處理回調(diào)行為。為了簡單化，我們從一個(gè)單獨(dú)的計(jì)算按鈕被按次數(shù)的回調(diào)開始。

首先，讓我們定義一個(gè)簡單的Button 類。

// code-examples/Traits/ui/button.scala  
package ui  
class Button(val label: String) extends Widget {  
  def click() = {  
    // Logic to give the appearance of clicking a button...  
  }  
}  
 

這里是它的父類，Widget。

// code-examples/Traits/ui/widget.scala  
package ui  
abstract class Widget  
 

管理回調(diào)的邏輯（比如，clickedCallbacks 列表）被省略了，兩個(gè)主要構(gòu)造函數(shù)也是。只有按鈕的label 字段和click 方法被保留了下來。這個(gè)click 方法現(xiàn)在只關(guān)心一個(gè)“物理上的” 按鈕被單擊時(shí)候的可見表現(xiàn)。按鈕只有一個(gè)關(guān)心的東西，就是處理作為一個(gè)按鈕的本質(zhì)行為。

這里是一個(gè)實(shí)現(xiàn)了觀察者模式邏輯的Trait。

// code-examples/Traits/observer/observer.scala  
package observer  
Trait Subject {  
  type Observer = { def receiveUpdate(subject: Any) }  
  private var observers = List[Observer]()  
  def addObserver(observer:Observer) = observers ::= observer 
  def notifyObservers = observers foreach (_.receiveUpdate(this))  
}  
 

除了Trait 關(guān)鍵字，Subject 看起來就像一個(gè)普通的類。Subject 定義了所有它聲明的成員。Traits 可以聲明抽象成員，具體成員，或者兩者皆有，就像類所能做的一樣（參見《第6章 - Scala 高級面向?qū)ο缶幊獭返?ldquo;重寫類和Traits 的成員”章節(jié)獲取更多信息）。而且，Traits 能包含嵌套的Trait 和類定義，類也能包含嵌套的Trait 定義。

第一行定義了Observer 類型。這是一個(gè)結(jié)構(gòu)類型，形式是 { def receiveUpdate(subject:Any) }。結(jié)構(gòu)類型僅制定了子類型必須支持的結(jié)構(gòu)；你可以把它們看作是“匿名”類型。

在這個(gè)例子里，這個(gè)結(jié)構(gòu)類型由一個(gè)有著特定簽名的方法定義。任何有這個(gè)簽名的方法的類型都可以被用作為一個(gè)observer（觀察者）。我們會(huì)在《第12章 - Scala 類型系統(tǒng)》學(xué)習(xí)更多有關(guān)結(jié)構(gòu)類型的內(nèi)容。如果你想知道為什么我們不把Subject 作為參數(shù)，而是Any。我們會(huì)在《第13章 - 應(yīng)用程序設(shè)計(jì)》的“自我類型注解和抽象類型成員”章節(jié)來重習(xí)這個(gè)問題。

我們所需要注意的最主要的是這樣的結(jié)構(gòu)類型如何最小化了Subject Trait 和任何潛在的Trait 用戶之間的耦合。

注意

Subject 仍然通過結(jié)構(gòu)類型和Observer 中的方法名稱耦合在一起，例如，名為receiveUpdate 的方法。我們有幾種方法來省去這剩下的耦合。我們會(huì)在《第6章 - Scala 高級面向?qū)ο缶幊獭分械?ldquo;重寫抽象類型”章節(jié)看到如何做到這一點(diǎn)。

下面，我們聲明了一系列觀察者。我們定義了一個(gè)var，而不是val，因?yàn)長ist 是不可變的。所以我們必須在一個(gè)觀察者通過addObserver 方法被添加時(shí)創(chuàng)建一個(gè)新的列表。

我們會(huì)在《第7章 - Scala 對象系統(tǒng)》的“Scala 類型結(jié)構(gòu)”章節(jié)和《第8章 - Scala 函數(shù)式編程》中討論更多有關(guān)List 的細(xì)節(jié)?，F(xiàn)在，注意addObserver 使用了列表的cons “操作符”方法（::）來在一個(gè)列表前面加入一個(gè)觀察者。Scala 編譯器會(huì)聰明地把下面的語句，

observers ::= observer 
 

轉(zhuǎn)換成如下語句，

observerobservers = observer :: observers  
 

注意我們寫了observer:: observers，把已存的observers 列表放到了右邊?；貞浺幌?，所有的以: 結(jié)尾的方法是右綁定的。所以，前一個(gè)語句和下面的語句等價(jià)。

observersobservers = observers.::(observer)  
 

notifyObservers 方法遍歷所有的觀察者，使用foreach 方法，然后對每一個(gè)觀察者調(diào)用receiveUpdate 方法。（注意我們使用了“插入”操作符標(biāo)記法而不是observers.foreach。）我們使用占位符'_' 來縮短下面的表達(dá)式，

(obs) => obs.receiveUpdate(this)  
 

為這樣的表達(dá)式，

_.receiveUpdate(this)  
 

這個(gè)表達(dá)式實(shí)際上是一個(gè)“匿名函數(shù)”的函數(shù)體，在Scala 中稱為字面函數(shù)。這和其它語言中的Lambda 表達(dá)式或類似結(jié)構(gòu)相似。字面函數(shù)和閉包相關(guān)的概念會(huì)在《第8章 - Scala 函數(shù)式編程》的“字面函數(shù)和閉包”章節(jié)中被討論。

在Java 中，foreach 方法很可能會(huì)接受一個(gè)接口，你可能會(huì)傳遞一個(gè)實(shí)現(xiàn)了該接口的類的實(shí)例。（比如，典型的Comparable 使用的方法）。

在Scala 中，List[A].foreach 方法期待的參數(shù)類型為(A)=>Unit，這是一個(gè)函數(shù)，接受一個(gè)A 類型的參數(shù)，而A 標(biāo)識(shí)了列表的元素的類型（在這個(gè)例子中是Observer），然后返回Unit（和Java 的void 一樣）。

注意

我們在這個(gè)例子里選擇使用一個(gè)var 來表示不可變的觀察者的List。我們也可以使用val 和一個(gè)可變的類型，比如ListBuffer。這個(gè)選擇會(huì)在一個(gè)真實(shí)的應(yīng)用程序中顯得更加合理，但是我們希望避免介紹新的類來分散我們的注意。

再一次的，我們從一個(gè)小例子里學(xué)習(xí)了許多Scala 的知識(shí)?，F(xiàn)在，讓我們來用一用我們的Subject Trait。這里有一個(gè)ObservableButton，它繼承了Button，混合了Subject。

// code-examples/Traits/ui/observable-button.scala  
package ui  
import observer._  
class ObservableButton(name: String) extends Button(name) with Subject {  
  override def click() = {  
    super.click()  
    notifyObservers  
  }  
}  
 

我們從導(dǎo)入observer 包的所有東西開始，使用'_' 通配符。實(shí)際上，我們在這個(gè)包中只定義了Subject Trait。

新的類使用了with 關(guān)鍵字把Subject Trait 加到類中。ObserverButton 重寫了click 方法。使用super 關(guān)鍵字（參見《第6章 - Scala 高級面向?qū)ο缶幊獭返?ldquo;重寫抽象和具體方法”章節(jié)），它首先調(diào)用了“父類”的方法，Button.click，然后它通知觀察者。因?yàn)樾碌腸lick 方法重寫了Button 的具體實(shí)現(xiàn)，必須加上override 關(guān)鍵字。

with 關(guān)鍵字和Java 的對接口使用的implement 關(guān)鍵字類似。你可以是頂任意多的Traits，每一個(gè)都必須有with 關(guān)鍵字。

一個(gè)類可以繼承一個(gè)Trait，一個(gè)Trait 也可以繼承一個(gè)類。實(shí)際上，我們的Widget 類也可以被聲明為一個(gè)Trait。

注意

如果你定義一個(gè)類使用一個(gè)或多個(gè)Traits，而它又不繼承任何類，你必須對第一個(gè)列出的Trait 使用extends 關(guān)鍵字。

如果你不對第一個(gè)Trait 使用extends，例如寫成這樣。

// ERROR:  
class ObservableButton(name: String) with Button(name) with Subject {...}  
 

你會(huì)獲得如下錯(cuò)誤。

... error: ';' expected but 'with' found.  
       class ObservableButton(name: String) with Button(name) with Subject {...}  
                                            ^  
 

這個(gè)錯(cuò)誤實(shí)際上應(yīng)該說“with found，but extends expected。”（發(fā)現(xiàn)with 關(guān)鍵字，但是期望一個(gè)extends。）

要演示這部分代碼，讓我們從一個(gè)觀察按鈕點(diǎn)擊和記錄點(diǎn)擊數(shù)目的類開始。

// code-examples/Traits/ui/button-count-observer.scala  
package ui  
import observer._  
class ButtonCountObserver {  
  var count = 0 
  def receiveUpdate(subject: Any) = count += 1  
}  
 

左后，讓我們寫一個(gè)測試來運(yùn)用所有的類。我們會(huì)使用Specs 庫（在《第14章 - Scala 工具，庫和IDE 支持》的“Specs” 章節(jié)討論） 來寫一個(gè)行為驅(qū)動(dòng)（【BDD】）的“規(guī)范”來測試組合后的Button 和Subject 類型。

// code-examples/Traits/ui/button-observer-spec.scala  
package ui  
import org.specs._  
import observer._  
object ButtonObserverSpec extends Specification {  
  "A Button Observer" should {  
    "observe button clicks" in {  
      val observableButton = new ObservableButton("Okay")  
      val buttonObserver = new ButtonCountObserver  
      observableButton.addObserver(buttonObserver)  
      for (i <- 1 to 3) observableButton.click()  
      buttonObserver.count mustEqual 3  
    }  
  }  
}  
 

如果你從O'Reilly 網(wǎng)站下載了代碼例子，你可以按照README 文件的指示來編譯和運(yùn)行這個(gè)章節(jié)的例子。specs “目標(biāo)”的輸出應(yīng)該包含如下的內(nèi)容。

Specification "ButtonCountObserverSpec"  
  A Button Observer should  
  + observe button clicks  
Total for specification "ButtonCountObserverSpec":  
Finished in 0 second, 10 ms  
1 example, 1 expectation, 0 failure, 0 error  
 

注意字符串“A Button Observer Should”和“observe button clicks” 對應(yīng)了例子中的字符串。Specs 的輸出提供了一個(gè)漂亮的被測試的項(xiàng)目的需求，并假設(shè)為這些字符串做了合適的決定。

測試的主題創(chuàng)建了一個(gè)“Okay” ObservableButton 和一個(gè)ButtonCountObserver，把觀察者給了這個(gè)button。按鈕通過for 循環(huán)被按了3次。最后一行要求observer 的計(jì)數(shù)等于3。如果你習(xí)慣使用XUnit 風(fēng)格的TDD （測試驅(qū)動(dòng)開發(fā)）工具，例如JUnit 或者ScalaTest（參見《第14章 - Scala 工具，庫和IDE 支持》的“ScalaTest” 章節(jié)），那么最后一行等效于下面的JUnit 斷言。

assertEquals(3, buttonObserver.count)  
 

注意

Specs 庫（參見“Specs” 章節(jié)） 和ScalaTest 庫（參見“ScalaTest”章節(jié)）都支持行為驅(qū)動(dòng)開發(fā)[BDD]，測試驅(qū)動(dòng)開發(fā)[TDD] 的一種風(fēng)格，強(qiáng)調(diào)了測試的“規(guī)范”角色。

假設(shè)我們只需要一個(gè)ObservableButton 實(shí)例呢？我們實(shí)際上不用聲明一個(gè)繼承Subject 的Button 的子類。我們可以在創(chuàng)建實(shí)例的時(shí)候加上Trait。

下一個(gè)例子展示了一個(gè)修訂的Specs 文件，它實(shí)例化了一個(gè)Button，混合了Subject 作為聲明的一部分。

// code-examples/Traits/ui/button-observer-anon-spec.scala  
package ui  
import org.specs._  
import observer._  
object ButtonObserverAnonSpec extends Specification {  
  "A Button Observer" should {  
    "observe button clicks" in {  
      val observableButton = new Button("Okay") with Subject {  
        override def click() = {  
          super.click()  
          notifyObservers  
        }  
      }  
      val buttonObserver = new ButtonCountObserver  
      observableButton.addObserver(buttonObserver)  
      for (i <- 1 to 3) observableButton.click()  
      buttonObserver.count mustEqual 3  
    }  
  }  
}  
 

修訂過的observableButton 的聲明實(shí)際上創(chuàng)建了一個(gè)匿名類，并且像之前那樣重寫了click 方法。和在Java 中創(chuàng)建匿名類的主要區(qū)別是我們可以在過程中引入Trait。Java 不允許你在實(shí)例化一個(gè)類的時(shí)候?qū)崿F(xiàn)一個(gè)新的接口。

最后，注意一個(gè)實(shí)例的繼承結(jié)構(gòu)會(huì)因?yàn)榛旌狭死^承自其它Traits 的Traits 而變得復(fù)雜。我們會(huì)在《第7章 - Scala 對象系統(tǒng)》的“對象層次結(jié)構(gòu)的線性化”章節(jié)來討論這些層次結(jié)構(gòu)的細(xì)節(jié)。

#p#

可堆疊Traits

我們可以通過一系列精煉來提高我們工作的可重用性，使得我們可以更容易地同時(shí)使用一個(gè)以上的Trait，例如，“堆疊”它們。

首先，讓我們來引入一個(gè)新的Trait，Clickable，一個(gè)任意構(gòu)件響應(yīng)點(diǎn)擊事件的抽象。

// code-examples/Traits/ui2/clickable.scala  
package ui2  
Trait Clickable {  
  def click()  
}  
 

注意

我們由一個(gè)新的包，ui2 開始，這樣我們可以更容易的區(qū)分開下載下來的新舊代碼。

Clickable Trait 看上去就像一個(gè)Java 接口；它是完全抽象的。它定義了一個(gè)單獨(dú)的抽象的方法，click。因?yàn)樗鼪]有函數(shù)體，所以稱之為抽象。如果Clickable 是一個(gè)類的話，我們則應(yīng)該在class 關(guān)鍵字前面加上abstract 關(guān)鍵字。但是這對于Trait 來說不是必須的。

這里是重構(gòu)過的按鈕類，使用了這個(gè)Trait。

// code-examples/Traits/ui2/button.scala  
package ui2  
import ui.Widget  
class Button(val label: String) extends Widget with Clickable {  
  def click() = {  
    // Logic to give the appearance of clicking a button...  
  }  
}  
 

這段代碼就像Java 實(shí)現(xiàn)一個(gè)Clickable 接口一樣。

當(dāng)我們在前面定義ObservableButton 的時(shí)候（在“混合Traits”章節(jié)），我們重寫了Button.click 來通知觀察者。而我們在聲明observableButton 為一個(gè)按鈕實(shí)例的時(shí)候，我們直接混合了Subject Trait，它重復(fù)了ButtonObserverAnonSpec 的邏輯。讓我們來消除這個(gè)重復(fù)。

當(dāng)我們開始用這種方式重構(gòu)代碼的時(shí)候，我們意識(shí)到我們實(shí)際上不關(guān)心“觀察”按鈕；我們關(guān)心的是“觀察”點(diǎn)擊。這里是一個(gè)單一的專注于觀察點(diǎn)擊的Trait。

// code-examples/Traits/ui2/observable-clicks.scala  
package ui2  
import observer._  
Trait ObservableClicks extends Clickable with Subject {  
  abstract override def click() = {  
    super.click()  
    notifyObservers  
  }  
}  
 

ObservableClick Trait 繼承自Clickable，并且混合了Subject。然后它重寫了click 方法，像在“混合Traits”章節(jié)重寫的方法幾乎一樣的實(shí)現(xiàn)。最重要的區(qū)別就是abstract 關(guān)鍵字。

仔細(xì)看這個(gè)方法。它調(diào)用了super.click()，但是這里super 是什么意思？在這里，它看上去只能是聲明了但是沒有定義click 方法的Clickable，或者Subject，它并沒有click 方法。所以，super 的身份還不一定，至少現(xiàn)在還不一定。

實(shí)際上，super 會(huì)在這個(gè)Trait 混入一個(gè)定義了具體click 方法的實(shí)例的時(shí)候被綁定。這樣，我們需要在ObservableClicks.click 前加上abstract 關(guān)鍵字來告訴編譯器（或者讀者）click 還沒有被完全實(shí)現(xiàn)，即使ObservableClicks.click 有一個(gè)函數(shù)體。

注意

除了聲明抽象類，abstract 關(guān)鍵字只在Trait 的方法有函數(shù)體，但是調(diào)用了在父類沒有具體實(shí)現(xiàn)的super 的方法的時(shí)候需要。

讓我們在Specs 測試中和Button 類以及它的具體click 方法一起使用這個(gè)Trait。

// code-examples/Traits/ui2/button-clickable-observer-spec.scala  
package ui2  
import org.specs._  
import observer._  
import ui.ButtonCountObserver  
object ButtonClickableObserverSpec extends Specification {  
  "A Button Observer" should {  
    "observe button clicks" in {  
      val observableButton = new Button("Okay") with ObservableClicks  
      val buttonClickCountObserver = new ButtonCountObserver  
      observableButton.addObserver(buttonClickCountObserver)  
      for (i <- 1 to 3) observableButton.click()  
      buttonClickCountObserver.count mustEqual 3  
    }  
  }  
}  
 

把這段代碼和ButtonObserverAnonSpec 比較。我們初始化了一個(gè)Button，混入ObservableClicks Trait，但是這次我們不需要重寫click 方法。所以，這個(gè)Button 的使用者不用惦記著重寫一個(gè)合適的click。這部分工作已經(jīng)由ObservableClicks 完成。想要的行為在我們需要的時(shí)候被聲明性地組合到代碼里去。

讓我們再來加入一個(gè)Trait。JavaBeans 規(guī)范[JavaBeanSpec] 有“可否決”事件的概念，是說JavaBean 修改的監(jiān)聽者可以否決修改。讓我們來用Trait 來實(shí)現(xiàn)一個(gè)類似的機(jī)制，用來否決一系列的點(diǎn)擊。

// code-examples/Traits/ui2/vetoable-clicks.scala  
package ui2  
import observer._  
Trait VetoableClicks extends Clickable {  
  val maxAllowed = 1  // default  
  private var count = 0 
  abstract override def click() = {  
    if (count < maxAllowed) {  
      count += 1  
      super.click()  
    }  
  }  
}  
 
    
 

再一次，我們重寫了click 方法。和以前一樣，必須聲明這個(gè)重寫是抽象的。允許點(diǎn)擊的數(shù)目默認(rèn)值是1。你可能想知道這里的默認(rèn)是什么？這個(gè)字段不是被聲明為val 嗎？ 我們沒有聲明構(gòu)造函數(shù)用其它值來初始化它。我們會(huì)在《第6章 - Scala 高級面向?qū)ο缶幊獭返?rdquo;重寫類和Traits 的成員“ 重溫這個(gè)問題。

這個(gè)Trait 還聲明了一個(gè)count 變量來記錄我們觀察到的點(diǎn)擊。它被定義為private （私有的），所以它對于Trait 外部的域來說是不可見的（參見《第5章 - Scala 基礎(chǔ)面向?qū)ο缶幊獭返?rdquo;可見域規(guī)則“）。被重寫的click 方法會(huì)增加count。它只在count 小于等于maxAllowed 數(shù)目的時(shí)候調(diào)用super.click()。

這里是展示ObservableClicks 和VetoableClicks 一起工作的Specs 對象。注意每一個(gè)Trait 都需要一個(gè)單獨(dú)的with 關(guān)鍵字，和Java 對于implements 指令只要一個(gè)關(guān)鍵字和用逗號隔開名稱的實(shí)現(xiàn)方式不一樣。

// code-examples/Traits/ui2/button-clickable-observer-vetoable-spec.scala  
package ui2  
import org.specs._  
import observer._  
import ui.ButtonCountObserver  
object ButtonClickableObserverVetoableSpec extends Specification {  
  "A Button Observer with Vetoable Clicks" should {  
    "observe only the first button click" in {  
      val observableButton =  
          new Button("Okay") with ObservableClicks with VetoableClicks  
      val buttonClickCountObserver = new ButtonCountObserver  
      observableButton.addObserver(buttonClickCountObserver)  
      for (i <- 1 to 3) observableButton.click()  
      buttonClickCountObserver.count mustEqual 1  
    }  
  }  
}  
 
 
 

觀察者的計(jì)數(shù)應(yīng)該是1。observableButton 有下面的語句聲明，

new Button("Okay") with ObservableClicks with VetoableClicks  
 

我們可以推斷VetoableClicks 重寫的click 在ObservableClicks 重寫的click 之前被調(diào)用。大概地講，因?yàn)槲覀兊哪涿悰]有定義自己的click，所以這個(gè)方法會(huì)按照聲明從右到左開始尋找。實(shí)際上比這個(gè)更復(fù)雜，我們會(huì)在《第7章 - Scala 對象系統(tǒng)》的”對象結(jié)構(gòu)的線性化“ 章節(jié)討論。

同時(shí)，如果我們把使用Trait 的順序反過來會(huì)發(fā)生什么呢？

// code-examples/Traits/ui2/button-vetoable-clickable-observer-spec.scala  
package ui2  
import org.specs._  
import observer._  
import ui.ButtonCountObserver  
object ButtonVetoableClickableObserverSpec extends Specification {  
  "A Vetoable Button with Click Observer" should {  
    "observe all the button clicks, even when some are vetoed" in {  
      val observableButton =  
          new Button("Okay") with VetoableClicks with ObservableClicks  
      val buttonClickCountObserver = new ButtonCountObserver  
      observableButton.addObserver(buttonClickCountObserver)  
      for (i <- 1 to 3) observableButton.click()  
      buttonClickCountObserver.count mustEqual 3  
    }  
  }  
}  
 

現(xiàn)在觀察者的計(jì)數(shù)應(yīng)該是3。ObservableClicks 現(xiàn)在比VetoableClicks 擁有更高的優(yōu)先級，所以點(diǎn)擊的計(jì)數(shù)會(huì)增加，即使有些點(diǎn)擊在接下來的動(dòng)作中被否決！

所以，為了防止Trait 之間互相影響導(dǎo)致不可預(yù)料的后果，聲明的順序很重要。也許另外一個(gè)教訓(xùn)是，把對象分拆成太多細(xì)密的Traits 可能會(huì)值得你代碼的執(zhí)行變得復(fù)雜費(fèi)解。

把你的程序分割成小的，個(gè)所有長的Trait 是個(gè)創(chuàng)建可重用，可伸縮的抽象和”組件“的強(qiáng)大方式。復(fù)雜的行為可以通過聲明Trait 的組合來完成。我們會(huì)在《第13章 - 應(yīng)用程序設(shè)計(jì)》的“可伸縮的抽象”中更多地探索這個(gè)概念。

構(gòu)造Traits

Traits 不支持輔助構(gòu)造函數(shù)，它們也不支持在主構(gòu)造函數(shù)，Trait 的主體里的參數(shù)列表。Traits 可以繼承類或者其它Trait。然而，因?yàn)樗鼈儾荒芙o父類的構(gòu)造函數(shù)傳遞參數(shù)（哪怕是字面值），所以Traits 只能繼承有無參數(shù)的主/副構(gòu)造函數(shù)的類。

然而，不像類，Trait 的主體在每次使用Trait 創(chuàng)建一個(gè)實(shí)例的時(shí)候都會(huì)被執(zhí)行，正如下面的腳本所演示。

// code-examples/Traits/Trait-construction-script.scala  
Trait T1 {  
  println( "  in T1: x = " + x )  
  val x=1 
  println( "  in T1: x = " + x )  
}  
Trait T2 {  
  println( "  in T2: y = " + y )  
  val y="T2" 
  println( "  in T2: y = " + y )  
}  
class Base12 {  
  println( "  in Base12: b = " + b )  
  val b="Base12" 
  println( "  in Base12: b = " + b )  
}  
class C12 extends Base12 with T1 with T2 {  
  println( "  in C12: c = " + c )  
  val c="C12" 
  println( "  in C12: c = " + c )  
}  
println( "Creating C12:" )  
new C12println( "After Creating C12" )  
 

用scala 命令運(yùn)行這段腳本會(huì)得到以下輸出。

Creating C12:  
  in Base12: b = null 
  in Base12: b = Base12 
  in T1: x = 0 
  in T1: x = 1 
  in T2: y = null 
  in T2: y = T2 
  in C12: c = null 
  in C12: c = C12 
After Creating C12  
 
    
 

注意類和Trait 構(gòu)造函數(shù)的調(diào)用順序。因?yàn)镃12 的聲明繼承自Base12 with T1 with T2，這個(gè)類結(jié)構(gòu)的構(gòu)造順序是從左到右的，從基類Base12 開始，接著是Traits T1 和T2，最后是C12 的構(gòu)造主體。（對于構(gòu)造任意復(fù)雜的結(jié)構(gòu)，參見《第7章 - Scala 對象系統(tǒng)》的“對象結(jié)構(gòu)的線性化”章節(jié)。）

所以，雖然你不能傳遞構(gòu)造參數(shù)給Trait，你可以用默認(rèn)值初始化字段，或讓它們繼續(xù)抽象。我們實(shí)際上在前面的Subject Trait 中見過， Subject.observers 字段被初始化為一個(gè)空列表。

如果Trait 的一個(gè)具體字段沒有合適的默認(rèn)值，那么就沒有一個(gè)“萬無一失”的方式來初始化這個(gè)值了。所有的其它方法都需要這個(gè)Trait 的用戶的一些特別步驟，這很容易發(fā)生錯(cuò)誤，因?yàn)樗麄兛赡軙?huì)做錯(cuò)甚至忘記去做。也許這個(gè)字段應(yīng)該繼續(xù)作為抽象字段，這樣類和其它Trait 使用它的時(shí)候會(huì)被強(qiáng)制定義一個(gè)合適的值。我們會(huì)在《第6章 - Scala 高級面向?qū)ο缶幊獭分性敿?xì)討論重寫抽象和具體成員。

另外一個(gè)解決方案是把這個(gè)字段轉(zhuǎn)移到一個(gè)單獨(dú)的類中，這樣構(gòu)造過程可以保證用戶可以提供正確的初始化數(shù)據(jù)。這樣也許應(yīng)該說這整個(gè)Trait 實(shí)際上應(yīng)該是一個(gè)類，這樣你才能定義一個(gè)構(gòu)造函數(shù)來初始化這個(gè)字段。

類還是Trait？

當(dāng)我們考慮是否一個(gè)“概念”應(yīng)該成為一個(gè)Trait 或者一個(gè)類的時(shí)候，記住作為混入的Trait 對于“附屬”行為來說最有意義。如果你發(fā)現(xiàn)某一個(gè)Trait 經(jīng)常作為其它類的父類來用，導(dǎo)致子類會(huì)有像父Trait 那樣的行為，那么考慮把它定義為一個(gè)類吧，讓這段邏輯關(guān)系更加清晰。（我們說像。。。的行為，而不是是。。。，因?yàn)榍罢呤抢^承更精確的定義，基于Liskov Substitution Principle -- 例如參見 [Martin2003]。）

提示

在Trait 里避免不能用合適的默認(rèn)值初始化的具體字段。使用抽象字段，或者把這個(gè)Trait 轉(zhuǎn)換成一個(gè)有構(gòu)造函數(shù)的類。當(dāng)然，無狀態(tài)Trait 沒有初始化的問題。

一個(gè)實(shí)例應(yīng)該從構(gòu)造過程結(jié)束開始，永遠(yuǎn)都在一個(gè)已知的有效的狀態(tài)下，這是優(yōu)秀的面向?qū)ο笤O(shè)計(jì)的基本原則。

概括，及下章預(yù)告

在這一章，我們學(xué)習(xí)了如何使用Trait 來封裝和共享類之間正交的關(guān)注點(diǎn)。我們也學(xué)習(xí)了何時(shí)，以及如何使用Trait，如果“堆疊”多個(gè)Trait，以及初始化Trait 的成員的規(guī)則。

在下一章，我們會(huì)探索Scala 編程中的面向?qū)ο蠡A(chǔ)。即使你是一個(gè)面向?qū)ο缶幊痰睦鲜?，你也?huì)希望通過閱讀下面的章節(jié)來理解Scala 面向?qū)ο蠓椒ǖ姆椒矫婷妗?/p>

51CTO推薦專題

[[16158]]

【編輯推薦】

1. 《Scala編程指南》第一章
2. 《Scala編程指南》第二章 
3. 《Scala編程指南》第三章 
4. 51CTO專訪Scala創(chuàng)始人：Scala拒絕學(xué)術(shù)化
5. “Scala” 一個(gè)有趣的語言