您所在的位置:开发 > Java > Java+ > Scala编程指南 了解Traits功能(1)

Scala编程指南 了解Traits功能(1)

2010-10-14 13:50 bbsmrdj 51CTO 字号:T | T
一键收藏,随时查看,分享好友!

本文为《Scala编程指南》的第四部分,将介绍Traits功能。Scala 是一种基于JVM,集合了面向对象编程和函数式编程优点的高级程序设计语言。

AD:

近日,Scala的创始人发表了“Scala is for good programmers(Scala语言是给专家级程序员的)”这样的言论!Scala在现在这个阶段并不需要适合一般的Java程序员。要吸引的是一些专家级的程序员——优秀的程序员。目标是使他们工作起来比使用Java更有效率。只有会出现足够多的教育示范材料和足够好的开发工具时,Scala对广大的普通开发人员才具有吸引力。但是Scala语言什么呢?

Scala编程指南》系列文章将会详细介绍Scala语言。本文为《Scala编程指南》系列的第四章,将介绍Traits功能。

Traits 介绍

在我们深入面向对象编程之前,我们还需要了解Scala 一个特性:Traits。要了解这个功能需要一点历史知识。

在Java 中,一个类可以实现任意数量的接口。这个模型在声明一个类实现多个抽象的时候非常有用。不幸的是,它也有一个主要缺点。

对于许多接口,大多数功能都可以用对于所有使用这个接口的类都有效的“样板”代码来实现。Java 没有提供一个内置机制来定义和使用这些可重用代码。相反的,Java 程序员必须使用一个特别的转换来重用一个已知接口的实现。在最坏的情况下,程序员必须复制粘贴同样的代码到不同的类中去。

通常,一个接口的实现拥有和该实例的其它成员无关(正交)的成员。术语mixin (混合)通常被用来指实例中这些专注的,潜在可被重用的,并且可以独立维护的代码。

来看一下下面这个图形用户接口的按钮的代码,它对单击事件使用了回调。

  1. // code-examples/Traits/ui/button-callbacks.scala  
  2. package ui  
  3. class ButtonWithCallbacks(val label: String,  
  4.     val clickedCallbacks: List[() => Unit]) extends Widget {  
  5.  
  6.   require(clickedCallbacks != null, "Callback list can't be null!")  
  7.  
  8.   def this(label: String, clickedCallback: () => Unit) =  
  9.     this(label, List(clickedCallback))  
  10.  
  11.   def this(label: String) = {  
  12.     this(label, Nil)  
  13.     println("Warning: button has no click callbacks!")  
  14.   }  
  15.  
  16.   def click() = {  
  17.     // ... logic to give the appearance of clicking a physical button ...  
  18.     clickedCallbacks.foreach(f => f())  
  19.   }  
  20. }  

这里发生了很多事情。主构造函数接受一个label(标签)参数和一个callbacks(回调)的list(列表),这些回调函数会在按钮的click 方法被调用时被调用。我们会在《第5章 - Scala 基础面向对象编程》中来探索这个类的更多细节。现在,我们希望专注在一个特别的问题上。ButtonWithCallbacks 不仅处理按钮的一些本质行为(比如单击),它同时还通过调用回调函数处理单击事件的通知。这违反了单职原则[Martin2003],这是分隔职能的一种设计方法。我们可以把按钮类的逻辑从回调逻辑中分离出来,这样每一个逻辑组件变得更加简单,更模块化,更可重用化。这个回调逻辑就是mixin 的一个不错例子。

这样的分离在Java 中很难做,即使我们定义了具有回调行为的接口,我们仍然需要在类中集成实现代码,降低模块性。唯一的其它方法则是使用特定的工具比如面向方面编程(Aspect-Oriented Programming,AOP,参见[AOSD]),一个实现是AspectJ,Java 的一个扩展。AOP 主要被设计用来分离在应用程序中重复出现的普遍问题的实现。它设法模块化这些关键点,但是也允许设计良好的和其它关键点行为的“混合”,包括应用程序的核心域逻辑,不管是在编译时还是运行时。

作为混合体的Traits

Scala 提供了完整的混合(mixin)解决方案,称为Traits。在我们的例子里,我们可以定义回调的抽象为一个Trait,就像一个Java 接口一样,但是我们可以实现这些Trait (或者继承的Trait)的抽象。我们可以定义混合了Trait 的类,大致上很像实现Java 的一个接口。不过,在Scala 你甚至可以在我们创建实例的时候混合Traits。也就是说,我们不必首先声明一个混合了所有我们所需要的Trait 的类。所以,Scala Traits 在保留分离关键点的同时给了我们按需整合行为的能力。

如果你来自于Java 编程世界,你可以认为Traits 是有选择地实现了的接口。其它语言提供了类似Trait 的结构,比如Ruby 中的模块(modules)。

让我们对按钮的逻辑来使用Trait,从而分离回调的处理。我们会推广一下我们的实现。回调其实是观察者模式[GOF1995] 的一个特例。所以,让我们创建一个Trait 来实现这个模式,然后用它来处理回调行为。为了简单化,我们从一个单独的计算按钮被按次数的回调开始。

首先,让我们定义一个简单的Button 类。

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

这里是它的父类,Widget。

  1. // code-examples/Traits/ui/widget.scala  
  2. package ui  
  3. abstract class Widget  
  4.  

管理回调的逻辑(比如,clickedCallbacks 列表)被省略了,两个主要构造函数也是。只有按钮的label 字段和click 方法被保留了下来。这个click 方法现在只关心一个“物理上的” 按钮被单击时候的可见表现。按钮只有一个关心的东西,就是处理作为一个按钮的本质行为。

这里是一个实现了观察者模式逻辑的Trait。

  1. // code-examples/Traits/observer/observer.scala  
  2. package observer  
  3. Trait Subject {  
  4.   type Observer = { def receiveUpdate(subject: Any) }  
  5.   private var observers = List[Observer]()  
  6.   def addObserver(observer:Observer) = observers ::observer 
  7.   def notifyObservers = observers foreach (_.receiveUpdate(this))  
  8. }  
  9.  

除了Trait 关键字,Subject 看起来就像一个普通的类。Subject 定义了所有它声明的成员。Traits 可以声明抽象成员,具体成员,或者两者皆有,就像类所能做的一样(参见《第6章 - Scala 高级面向对象编程》的“重写类和Traits 的成员”章节获取更多信息)。而且,Traits 能包含嵌套的Trait 和类定义,类也能包含嵌套的Trait 定义。

第一行定义了Observer 类型。这是一个结构类型,形式是 { def receiveUpdate(subject:Any) }。结构类型仅制定了子类型必须支持的结构;你可以把它们看作是“匿名”类型。

在这个例子里,这个结构类型由一个有着特定签名的方法定义。任何有这个签名的方法的类型都可以被用作为一个observer(观察者)。我们会在《第12章 - Scala 类型系统》学习更多有关结构类型的内容。如果你想知道为什么我们不把Subject 作为参数,而是Any。我们会在《第13章 - 应用程序设计》的“自我类型注解和抽象类型成员”章节来重习这个问题。

我们所需要注意的最主要的是这样的结构类型如何最小化了Subject Trait 和任何潜在的Trait 用户之间的耦合。

注意

Subject 仍然通过结构类型和Observer 中的方法名称耦合在一起,例如,名为receiveUpdate 的方法。我们有几种方法来省去这剩下的耦合。我们会在《第6章 - Scala 高级面向对象编程》中的“重写抽象类型”章节看到如何做到这一点。

下面,我们声明了一系列观察者。我们定义了一个var,而不是val,因为List 是不可变的。所以我们必须在一个观察者通过addObserver 方法被添加时创建一个新的列表。

我们会在《第7章 - Scala 对象系统》的“Scala 类型结构”章节和《第8章 - Scala 函数式编程》中讨论更多有关List 的细节。现在,注意addObserver 使用了列表的cons “操作符”方法(::)来在一个列表前面加入一个观察者。Scala 编译器会聪明地把下面的语句,

  1. observers ::observer 
  2.  

转换成如下语句,

  1. observerobservers = observer :: observers  
  2.  

注意我们写了observer:: observers,把已存的observers 列表放到了右边。回忆一下,所有的以: 结尾的方法是右绑定的。所以,前一个语句和下面的语句等价。

  1. observersobservers = observers.::(observer)  
  2.  

notifyObservers 方法遍历所有的观察者,使用foreach 方法,然后对每一个观察者调用receiveUpdate 方法。(注意我们使用了“插入”操作符标记法而不是observers.foreach。)我们使用占位符'_' 来缩短下面的表达式,

  1. (obs) => obs.receiveUpdate(this)  
  2.  

为这样的表达式,

  1. _.receiveUpdate(this)  
  2.  

这个表达式实际上是一个“匿名函数”的函数体,在Scala 中称为字面函数。这和其它语言中的Lambda 表达式或类似结构相似。字面函数和闭包相关的概念会在《第8章 - Scala 函数式编程》的“字面函数和闭包”章节中被讨论。

在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。

  1. // code-examples/Traits/ui/observable-button.scala  
  2. package ui  
  3. import observer._  
  4. class ObservableButton(name: String) extends Button(name) with Subject {  
  5.   override def click() = {  
  6.     super.click()  
  7.     notifyObservers  
  8.   }  
  9. }  
  10.  

我们从导入observer 包的所有东西开始,使用'_' 通配符。实际上,我们在这个包中只定义了Subject Trait。

新的类使用了with 关键字把Subject Trait 加到类中。ObserverButton 重写了click 方法。使用super 关键字(参见《第6章 - Scala 高级面向对象编程》的“重写抽象和具体方法”章节),它首先调用了“父类”的方法,Button.click,然后它通知观察者。因为新的click 方法重写了Button 的具体实现,必须加上override 关键字。

with 关键字和Java 的对接口使用的implement 关键字类似。你可以是顶任意多的Traits,每一个都必须有with 关键字。

一个类可以继承一个Trait,一个Trait 也可以继承一个类。实际上,我们的Widget 类也可以被声明为一个Trait。

注意

如果你定义一个类使用一个或多个Traits,而它又不继承任何类,你必须对第一个列出的Trait 使用extends 关键字。

如果你不对第一个Trait 使用extends,例如写成这样。

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

你会获得如下错误。

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

这个错误实际上应该说“with found,but extends expected。”(发现with 关键字,但是期望一个extends。)

要演示这部分代码,让我们从一个观察按钮点击和记录点击数目的类开始。

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

左后,让我们写一个测试来运用所有的类。我们会使用Specs 库(在《第14章 - Scala 工具,库和IDE 支持》的“Specs” 章节讨论) 来写一个行为驱动(【BDD】)的“规范”来测试组合后的Button 和Subject 类型。

  1. // code-examples/Traits/ui/button-observer-spec.scala  
  2. package ui  
  3. import org.specs._  
  4. import observer._  
  5. object ButtonObserverSpec extends Specification {  
  6.   "A Button Observer" should {  
  7.     "observe button clicks" in {  
  8.       val observableButton = new ObservableButton("Okay")  
  9.       val buttonObserver = new ButtonCountObserver  
  10.       observableButton.addObserver(buttonObserver)  
  11.       for (i <- 1 to 3) observableButton.click()  
  12.       buttonObserver.count mustEqual 3  
  13.     }  
  14.   }  
  15. }  
  16.  

如果你从O'Reilly 网站下载了代码例子,你可以按照README 文件的指示来编译和运行这个章节的例子。specs “目标”的输出应该包含如下的内容。

  1. Specification "ButtonCountObserverSpec"  
  2.   A Button Observer should  
  3.   + observe button clicks  
  4. Total for specification "ButtonCountObserverSpec":  
  5. Finished in 0 second, 10 ms  
  6. 1 example, 1 expectation, 0 failure, 0 error  
  7.  

注意字符串“A Button Observer Should”和“observe button clicks” 对应了例子中的字符串。Specs 的输出提供了一个漂亮的被测试的项目的需求,并假设为这些字符串做了合适的决定。

测试的主题创建了一个“Okay” ObservableButton 和一个ButtonCountObserver,把观察者给了这个button。按钮通过for 循环被按了3次。最后一行要求observer 的计数等于3。如果你习惯使用XUnit 风格的TDD (测试驱动开发)工具,例如JUnit 或者ScalaTest(参见《第14章 - Scala 工具,库和IDE 支持》的“ScalaTest” 章节),那么最后一行等效于下面的JUnit 断言。

  1. assertEquals(3, buttonObserver.count)  
  2.  

注意

Specs 库(参见“Specs” 章节) 和ScalaTest 库(参见“ScalaTest”章节)都支持行为驱动开发[BDD],测试驱动开发[TDD] 的一种风格,强调了测试的“规范”角色。

假设我们只需要一个ObservableButton 实例呢?我们实际上不用声明一个继承Subject 的Button 的子类。我们可以在创建实例的时候加上Trait。

下一个例子展示了一个修订的Specs 文件,它实例化了一个Button,混合了Subject 作为声明的一部分。

  1. // code-examples/Traits/ui/button-observer-anon-spec.scala  
  2. package ui  
  3. import org.specs._  
  4. import observer._  
  5. object ButtonObserverAnonSpec extends Specification {  
  6.   "A Button Observer" should {  
  7.     "observe button clicks" in {  
  8.       val observableButton = new Button("Okay") with Subject {  
  9.         override def click() = {  
  10.           super.click()  
  11.           notifyObservers  
  12.         }  
  13.       }  
  14.       val buttonObserver = new ButtonCountObserver  
  15.       observableButton.addObserver(buttonObserver)  
  16.       for (i <- 1 to 3) observableButton.click()  
  17.       buttonObserver.count mustEqual 3  
  18.     }  
  19.   }  
  20. }  
  21.  

修订过的observableButton 的声明实际上创建了一个匿名类,并且像之前那样重写了click 方法。和在Java 中创建匿名类的主要区别是我们可以在过程中引入Trait。Java 不允许你在实例化一个类的时候实现一个新的接口。

最后,注意一个实例的继承结构会因为混合了继承自其它Traits 的Traits 而变得复杂。我们会在《第7章 - Scala 对象系统》的“对象层次结构的线性化”章节来讨论这些层次结构的细节。

内容导航



分享到:

热点职位

更多>>

热点专题

更多>>

读书

Java (JDK 6)学习笔记
Java学习笔记在JavaWorld技术论坛(http://www.javaworld.com.tw/)和作者的网站(http://caterpillar.onlyfun.net/Gossip/)提

51CTO旗下网站

领先的IT技术网站 51CTO 领先的中文存储媒体 WatchStor 中国首个CIO网站 CIOage 中国首家数字医疗网站 HC3i