Scala編程指南了解Traits功能

作者：bbsmrdj 2010-10-14 13:50:11

本文為《Scala編程指南》的第四部分，將介紹Traits功能。Scala 是一種基于JVM，集合了面向對象編程和函數式編程優(yōu)點的高級程序設計語言。

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

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

Traits 介紹

在我們深入面向對象編程之前，我們還需要了解Scala 一個特性：Traits。要了解這個功能需要一點歷史知識。

在Java 中，一個類可以實現任意數量的接口。這個模型在聲明一個類實現多個抽象的時候非常有用。不幸的是，它也有一個主要缺點。

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

通常，一個接口的實現擁有和該實例的其它成員無關（正交）的成員。術語mixin （混合）通常被用來指實例中這些專注的，潛在可被重用的，并且可以獨立維護的代碼。

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

// 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ā)生了很多事情。主構造函數接受一個label（標簽）參數和一個callbacks（回調）的list（列表），這些回調函數會在按鈕的click 方法被調用時被調用。我們會在《第5章 - Scala 基礎面向對象編程》中來探索這個類的更多細節(jié)。現在，我們希望專注在一個特別的問題上。ButtonWithCallbacks 不僅處理按鈕的一些本質行為（比如單擊），它同時還通過調用回調函數處理單擊事件的通知。這違反了單職原則[Martin2003]，這是分隔職能的一種設計方法。我們可以把按鈕類的邏輯從回調邏輯中分離出來，這樣每一個邏輯組件變得更加簡單，更模塊化，更可重用化。這個回調邏輯就是mixin 的一個不錯例子。

這樣的分離在Java 中很難做，即使我們定義了具有回調行為的接口，我們仍然需要在類中集成實現代碼，降低模塊性。唯一的其它方法則是使用特定的工具比如面向方面編程（Aspect-Oriented Programming，AOP，參見[AOSD]），一個實現是AspectJ，Java 的一個擴展。AOP 主要被設計用來分離在應用程序中重復出現的普遍問題的實現。它設法模塊化這些關鍵點，但是也允許設計良好的和其它關鍵點行為的“混合”，包括應用程序的核心域邏輯，不管是在編譯時還是運行時。

作為混合體的Traits

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

如果你來自于Java 編程世界，你可以認為Traits 是有選擇地實現了的接口。其它語言提供了類似Trait 的結構，比如Ruby 中的模塊（modules）。

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

首先，讓我們定義一個簡單的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

管理回調的邏輯（比如，clickedCallbacks 列表）被省略了，兩個主要構造函數也是。只有按鈕的label 字段和click 方法被保留了下來。這個click 方法現在只關心一個“物理上的” 按鈕被單擊時候的可見表現。按鈕只有一個關心的東西，就是處理作為一個按鈕的本質行為。

這里是一個實現了觀察者模式邏輯的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 關鍵字，Subject 看起來就像一個普通的類。Subject 定義了所有它聲明的成員。Traits 可以聲明抽象成員，具體成員，或者兩者皆有，就像類所能做的一樣（參見《第6章 - Scala 高級面向對象編程》的“重寫類和Traits 的成員”章節(jié)獲取更多信息）。而且，Traits 能包含嵌套的Trait 和類定義，類也能包含嵌套的Trait 定義。

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

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

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

注意

Subject 仍然通過結構類型和Observer 中的方法名稱耦合在一起，例如，名為receiveUpdate 的方法。我們有幾種方法來省去這剩下的耦合。我們會在《第6章 - Scala 高級面向對象編程》中的“重寫抽象類型”章節(jié)看到如何做到這一點。

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

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

observers ::= observer

轉換成如下語句，

observerobservers = observer :: observers

注意我們寫了observer:: observers，把已存的observers 列表放到了右邊。回憶一下，所有的以: 結尾的方法是右綁定的。所以，前一個語句和下面的語句等價。

observersobservers = observers.::(observer)

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

(obs) => obs.receiveUpdate(this)

為這樣的表達式，

_.receiveUpdate(this)

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

在Java 中，foreach 方法很可能會接受一個接口，你可能會傳遞一個實現了該接口的類的實例。（比如，典型的Comparable 使用的方法）。

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

注意

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

再一次的，我們從一個小例子里學習了許多Scala 的知識。現在，讓我們來用一用我們的Subject Trait。這里有一個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  
  }  
}

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

新的類使用了with 關鍵字把Subject Trait 加到類中。ObserverButton 重寫了click 方法。使用super 關鍵字（參見《第6章 - Scala 高級面向對象編程》的“重寫抽象和具體方法”章節(jié)），它首先調用了“父類”的方法，Button.click，然后它通知觀察者。因為新的click 方法重寫了Button 的具體實現，必須加上override 關鍵字。

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

一個類可以繼承一個Trait，一個Trait 也可以繼承一個類。實際上，我們的Widget 類也可以被聲明為一個Trait。

注意

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

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

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

你會獲得如下錯誤。

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

這個錯誤實際上應該說“with found，but extends expected。”（發(fā)現with 關鍵字，但是期望一個extends。）

要演示這部分代碼，讓我們從一個觀察按鈕點擊和記錄點擊數目的類開始。

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

左后，讓我們寫一個測試來運用所有的類。我們會使用Specs 庫（在《第14章 - Scala 工具，庫和IDE 支持》的“Specs” 章節(jié)討論）來寫一個行為驅動（【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 網站下載了代碼例子，你可以按照README 文件的指示來編譯和運行這個章節(jié)的例子。specs “目標”的輸出應該包含如下的內容。

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” 對應了例子中的字符串。Specs 的輸出提供了一個漂亮的被測試的項目的需求，并假設為這些字符串做了合適的決定。

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

assertEquals(3, buttonObserver.count)

注意

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

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

下一個例子展示了一個修訂的Specs 文件，它實例化了一個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 的聲明實際上創(chuàng)建了一個匿名類，并且像之前那樣重寫了click 方法。和在Java 中創(chuàng)建匿名類的主要區(qū)別是我們可以在過程中引入Trait。Java 不允許你在實例化一個類的時候實現一個新的接口。

最后，注意一個實例的繼承結構會因為混合了繼承自其它Traits 的Traits 而變得復雜。我們會在《第7章 - Scala 對象系統》的“對象層次結構的線性化”章節(jié)來討論這些層次結構的細節(jié)。

#p#

可堆疊Traits

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

首先，讓我們來引入一個新的Trait，Clickable，一個任意構件響應點擊事件的抽象。

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

注意

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

Clickable Trait 看上去就像一個Java 接口；它是完全抽象的。它定義了一個單獨的抽象的方法，click。因為它沒有函數體，所以稱之為抽象。如果Clickable 是一個類的話，我們則應該在class 關鍵字前面加上abstract 關鍵字。但是這對于Trait 來說不是必須的。

這里是重構過的按鈕類，使用了這個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 實現一個Clickable 接口一樣。

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

當我們開始用這種方式重構代碼的時候，我們意識到我們實際上不關心“觀察”按鈕；我們關心的是“觀察”點擊。這里是一個單一的專注于觀察點擊的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é)重寫的方法幾乎一樣的實現。最重要的區(qū)別就是abstract 關鍵字。

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

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

注意

除了聲明抽象類，abstract 關鍵字只在Trait 的方法有函數體，但是調用了在父類沒有具體實現的super 的方法的時候需要。

讓我們在Specs 測試中和Button 類以及它的具體click 方法一起使用這個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 比較。我們初始化了一個Button，混入ObservableClicks Trait，但是這次我們不需要重寫click 方法。所以，這個Button 的使用者不用惦記著重寫一個合適的click。這部分工作已經由ObservableClicks 完成。想要的行為在我們需要的時候被聲明性地組合到代碼里去。

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

// 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 方法。和以前一樣，必須聲明這個重寫是抽象的。允許點擊的數目默認值是1。你可能想知道這里的默認是什么？這個字段不是被聲明為val 嗎？我們沒有聲明構造函數用其它值來初始化它。我們會在《第6章 - Scala 高級面向對象編程》的”重寫類和Traits 的成員“ 重溫這個問題。

這個Trait 還聲明了一個count 變量來記錄我們觀察到的點擊。它被定義為private （私有的），所以它對于Trait 外部的域來說是不可見的（參見《第5章 - Scala 基礎面向對象編程》的”可見域規(guī)則“）。被重寫的click 方法會增加count。它只在count 小于等于maxAllowed 數目的時候調用super.click()。

這里是展示ObservableClicks 和VetoableClicks 一起工作的Specs 對象。注意每一個Trait 都需要一個單獨的with 關鍵字，和Java 對于implements 指令只要一個關鍵字和用逗號隔開名稱的實現方式不一樣。

// 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  
    }  
  }  
}

觀察者的計數應該是1。observableButton 有下面的語句聲明，

new Button("Okay") with ObservableClicks with VetoableClicks

我們可以推斷VetoableClicks 重寫的click 在ObservableClicks 重寫的click 之前被調用。大概地講，因為我們的匿名類沒有定義自己的click，所以這個方法會按照聲明從右到左開始尋找。實際上比這個更復雜，我們會在《第7章 - Scala 對象系統》的”對象結構的線性化“ 章節(jié)討論。

同時，如果我們把使用Trait 的順序反過來會發(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  
    }  
  }  
}

現在觀察者的計數應該是3。ObservableClicks 現在比VetoableClicks 擁有更高的優(yōu)先級，所以點擊的計數會增加，即使有些點擊在接下來的動作中被否決！

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

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

構造Traits

Traits 不支持輔助構造函數，它們也不支持在主構造函數，Trait 的主體里的參數列表。Traits 可以繼承類或者其它Trait。然而，因為它們不能給父類的構造函數傳遞參數（哪怕是字面值），所以Traits 只能繼承有無參數的主/副構造函數的類。

然而，不像類，Trait 的主體在每次使用Trait 創(chuàng)建一個實例的時候都會被執(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 命令運行這段腳本會得到以下輸出。

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 構造函數的調用順序。因為C12 的聲明繼承自Base12 with T1 with T2，這個類結構的構造順序是從左到右的，從基類Base12 開始，接著是Traits T1 和T2，最后是C12 的構造主體。（對于構造任意復雜的結構，參見《第7章 - Scala 對象系統》的“對象結構的線性化”章節(jié)。）

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

如果Trait 的一個具體字段沒有合適的默認值，那么就沒有一個“萬無一失”的方式來初始化這個值了。所有的其它方法都需要這個Trait 的用戶的一些特別步驟，這很容易發(fā)生錯誤，因為他們可能會做錯甚至忘記去做。也許這個字段應該繼續(xù)作為抽象字段，這樣類和其它Trait 使用它的時候會被強制定義一個合適的值。我們會在《第6章 - Scala 高級面向對象編程》中詳細討論重寫抽象和具體成員。

另外一個解決方案是把這個字段轉移到一個單獨的類中，這樣構造過程可以保證用戶可以提供正確的初始化數據。這樣也許應該說這整個Trait 實際上應該是一個類，這樣你才能定義一個構造函數來初始化這個字段。

類還是Trait？

當我們考慮是否一個“概念”應該成為一個Trait 或者一個類的時候，記住作為混入的Trait 對于“附屬”行為來說最有意義。如果你發(fā)現某一個Trait 經常作為其它類的父類來用，導致子類會有像父Trait 那樣的行為，那么考慮把它定義為一個類吧，讓這段邏輯關系更加清晰。（我們說像。。。的行為，而不是是。。。，因為前者是繼承更精確的定義，基于Liskov Substitution Principle -- 例如參見 [Martin2003]。）

提示

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

一個實例應該從構造過程結束開始，永遠都在一個已知的有效的狀態(tài)下，這是優(yōu)秀的面向對象設計的基本原則。

概括，及下章預告

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

在下一章，我們會探索Scala 編程中的面向對象基礎。即使你是一個面向對象編程的老手，你也會希望通過閱讀下面的章節(jié)來理解Scala 面向對象方法的方方面面。

51CTO推薦專題

[[16158]]

【編輯推薦】

《Scala編程指南》第一章
《Scala編程指南》第二章
《Scala編程指南》第三章
51CTO專訪Scala創(chuàng)始人：Scala拒絕學術化
“Scala” 一個有趣的語言

責任編輯：佚名來源： 51CTO

Scala

Scala編程指南 了解Traits功能

Scala編程指南了解Traits功能