快学scala 第十章 特质 读书笔记及习题答案代码

chapter 10 特质

标签：快学scala

---

一、笔记

1. scala和java一样不允许从多个超类继承，scala提供特质而非接口。特质可以同时拥有抽象方法和具体方法，而类可以实现多个特质。 
   不需要将方法声明为abstract，特质中未被实现的方法默认就是抽象的。在重写特质的抽象方法时不需要给出override关键字。特质跟类更为相像。用with添加额外的特质：

 
 
   
   
   
   

    
    
    
    
class ConsoleLogger extends Logger with Cloneable with Serialiable    
   
   
   
   

由上，Logger ith Cloneable with Serialiable首先是一个整体，然后再由类来扩展。 
2. 特质的方法并不需要一定是抽象的：

 
 
   
   
   
   

    
    
    
    
trait ConsoleLogger{
    
    
    
    
    def log(msg: String) { println(msg)}
    
    
    
    
}
    
    
    
    
class SavingAccount extends Account with ConsoleLogger {
    
    
    
    
    def withdraw(amount: Double){
    
    
    
    
        if(amount > balance) log("Insufficient funds")
    
    
    
    
        else balance -= amount
    
    
    
    
    }
    
    
    
    
}  //scala与java的区别，SavingAccount从ConsoleLogger特质得到了一个具体的log方法，java的接口是不可能做到的。scala中是ConsoleLogger的功能被混入了SavingAccount类
   
   
   
   

1. JVM中，一个类只能扩展一个超类，因此来自特质的字段不能以相同的方式继承。
2. 对于特质的构造顺序：首先调用超类的构造器。特质构造器在超类构造器之后、类构造器之前执行。特质由左到右被构造。每个特质当中，父特质先被构造。如果多个特质共有一个父特质，而那个父特质已经被构造，则不会被再次构造。所有特质构造完毕，子类被构造。

 
 
   
   
   
   

    
    
    
    
class SavingsAccount extends Account with FileLogger with ShortLogger
    
    
    
    
//构造顺序是： Account（超类）Looger（第一个特质的父特质）FileLogger（第一个特质）ShortLogger（第二个特质，它的父特质Logger已被构造），SavingsAccount(类)
   
   
   
   

1. 特质不能有构造器参数，每个特质都有一个无参数的构造器。缺少构造器参数是特质和类之间唯一的技术差别。

 
 
   
   
   
   

    
    
    
    
val acct = new SavingsAccount with FileLogger("myapp.log")  //错误：特质不能使用构造器参数
   
   
   
   

FileLogger构造器先于子类构造器执行，在轮到子类之前，FileLogger的构造器就会抛出一个空指针异常。解决方法是 “提前定义”：

 
 
   
   
   
   

    
    
    
    
val acct = new{
    
    
    
    
    val filename = "myapp.log"
    
    
    
    
}with SavingsAccount with FileLogger //提前定义发生在常规的构造序列之前，在FileLogger被构造时，filename已经是初始化过的了
   
   
   
   

1. 特质可以扩展另一个特质，特质也可以扩展类，这个类会自动成为所有混入该特质的超类。在特质扩展类时，编译器能够确保的是所有混入该特质的类都认这个类作超类。scala还有另一套机制保证：自身类型

 
 
   
   
   
   

    
    
    
    
this: 类型 =>   
    
    
    
    
//当特质以这一定义开始时，它便被混入指定类型的子类
   
   
   
   

 
 
   
   
   
   

    
    
    
    
trait LoggedException extends Logged{
    
    
    
    
    this: Exception =>
    
    
    
    
        def log() { log(getMessage) }
    
    
    
    
} //该特质并不扩展Exception类，而是有一个自身类型Exception，这意味着，它只能被混入Exception的子类。
    
    
    
    
如果把特质混入一个不符合自身类型要求的类，就会报错
   
   
   
   

1. 6.

二、习题答案

10.1 java.awt.Rectangle类有两个很有用的方法translate和grow,但可惜的是像java.awt.geom.Ellipse2D这样的类没有。在Scala中，你可以解决掉这个问题。定义一个RenctangleLike特质,加入具体的translate和grow方法。提供任何你需要用来实现的抽象方法,以便你可以像如下代码这样混入该特质:

 
 
   
   
   
   

    
    
    
    
val egg = new java.awt.geom.Ellipse2D.Double(5,10,20,30) with RectangleLike
    
    
    
    
egg.translate(10,-10)
    
    
    
    
egg.grow(10,20)
   
   
   
   

 
 
   
   
   
   

    
    
    
    
import java.awt.geom.Ellipse2D
    
    
    
    

    
    
    
    
trait RectangleLike{  //使用自身类型使得trait可以操作x,y
    
    
    
    
    this:Ellipse2D.Double => 
    
    
    
    
    def translate(x: Double, y: Double){
    
    
    
    
        this.x = x
    
    
    
    
        this.y = y
    
    
    
    
    }
    
    
    
    
    def grow(x: Double, y: Double){
    
    
    
    
        this.x += x 
    
    
    
    
        this.y += y
    
    
    
    
    } 
    
    
    
    
}
    
    
    
    

    
    
    
    
object Test extends App{
    
    
    
    
    val egg = new Ellipse2D.Double(5,10,20,30) with RectangleLike
    
    
    
    
    println("x = " + egg.getX + " y = " + egg.getY)
    
    
    
    
    egg.translate(10, -10)
    
    
    
    
    println("x = " + egg.getX + " y = " + egg.getY)
    
    
    
    
    egg.grow(10, 20)
    
    
    
    
    println("x = " + egg.getX + " y = " + egg.getY)
    
    
    
    
}
   
   
   
   

10.2 把scala.math.Ordered[Point]混入java.awt.Point的方式，定义OrderedPoint类。按辞典编辑方式排序，也就是说，如果

 
 
   
   
   
   

    
    
    
    
x<x'或者x=x'且y<y'则(x,y)<(x',y')
   
   
   
   

 
 
   
   
   
   

    
    
    
    

    
    
    
    
import scala.math.Ordered
    
    
    
    
import java.awt.Point
    
    
    
    

    
    
    
    
class OrderedPoint(x: Int, y: Int) extends Point(x,y) with Ordered[Point]{ //Point(x,y)写全
    
    
    
    
    def compare(that: Point): Int = {
    
    
    
    
        if(this.x <= that.x){
    
    
    
    
            if(this.x == that.x) {
    
    
    
    
                if(this.y < that.y) -1
    
    
    
    
                else if(this.y > that.y) 1
    
    
    
    
                else 0
    
    
    
    
            }else -1
    
    
    
    
        }else -1
    
    
    
    
    }
    
    
    
    
    override def toString = "[%d, %d]".format(getX(), getY())    
    
    
    
    
}
    
    
    
    

    
    
    
    
val x1 = new OrderedPoint(1,1)
    
    
    
    
val x2 = new OrderedPoint(1,-1)
    
    
    
    
val x3 = new OrderedPoint(2,1)
    
    
    
    
println(x1 < x2)
    
    
    
    
println(x1 >= x3)
   
   
   
   

10.4 提供一个CryptoLogger类，将日志消息以凯撒密码加密。缺省情况下密匙为3，不过使用者也可以重写它。提供缺省密匙和-3作为密匙是的使用示例

 
 
   
   
   
   

    
    
    
    
trait Logger {
    
    
    
    
    def log(msg: String) = {}
    
    
    
    
}
    
    
    
    

    
    
    
    
trait ConsoleLogger extends Logger {
    
    
    
    
    override def log(msg: String) = Console.println(msg)
    
    
    
    
}
    
    
    
    

    
    
    
    
trait CaesarLogger extends Logger {
    
    
    
    
    val shift: Int = 3
    
    
    
    
    override def log(msg: String) = {
    
    
    
    
        super.log((for(x <- msg) yield (x + shift).toChar).mkString)
    
    
    
    
        // more elegant
    
    
    
    
        super.log(msg.map(_ + shift).map(_.toChar).mkString)
    
    
    
    
        // speedup but less elegant
    
    
    
    
        super.log(msg.map((x : Char) => (x + shift).toChar).mkString)
    
    
    
    
    }
    
    
    
    
}
    
    
    
    

    
    
    
    

    
    
    
    
class Sample extends Logger {
    
    
    
    
    def doSomeWork() = {
    
    
    
    
        log("Some Log Message")
    
    
    
    
    }
    
    
    
    
}
    
    
    
    

    
    
    
    
val x = new Sample with ConsoleLogger
    
    
    
    
x.doSomeWork
    
    
    
    

    
    
    
    
val y = new Sample with ConsoleLogger with CaesarLogger
    
    
    
    
y.doSomeWork
    
    
    
    

    
    
    
    
val z = new { override val shift = -3} with Sample with ConsoleLogger with CaesarLogger
    
    
    
    
z.doSomeWork
   
   
   
   

10.5 JavaBean规范里有一种提法叫做属性变更监听器(property change listener)，这是bean用来通知其属性变更的标准方式。PropertyChangeSupport类对于任何想要支持属性变更通知其属性变更监听器的bean而言是个便捷的超类。但可惜已有其他超类的类—比如JComponent—必须重新实现相应的方法。将PropertyChangeSupport重新实现为一个特质,然后将它混入到java.awt.Point类中

 
 
   
   
   
   

    
    
    
    
import java.awt.Point
    
    
    
    
import java.beans.PropertyChangeSupport
    
    
    
    

    
    
    
    
trait PropertyChange extends PropertyChangeSupport
    
    
    
    

    
    
    
    
val p = new Point() with PropertyChange
   
   
   
   

10.6 在Java AWT类库中,我们有一个Container类，一个可以用于各种组件的Component子类。举例来说,Button是一个Component,但Panel是Container。这是一个运转中的组合模式。Swing有JComponent和JContainer,但如果你仔细看的话，你会发现一些奇怪的细节。尽管把其他组件添加到比如JButton中毫无意义,JComponent依然扩展自Container。Swing的设计者们理想情况下应该会更倾向于图10-4中的设计。但在Java中那是不可能的。请解释这是为什么？Scala中如何用特质来设计出这样的效果?

 
 
   
   
   
   

    
    
    
    
Java只能单继承,JContainer不能同时继承自Container和JComponent。Scala可以通过特质解决这个问题.
   
   
   
   

10.7 市面上有不下数十种关于Scala特质的教程,用的都是些"在叫的狗"啦，"讲哲学的青蛙"啦之类的傻乎乎的例子。阅读和理解这些机巧的继承层级很乏味且对于理解问题没什么帮助,但自己设计一套继承层级就不同了,会很有启发。做一个你自己的关于特质的继承层级，要求体现出叠加在一起的特质,具体的和抽象的方法，以及具体的和抽象的字段

 
 
   
   
   
   

    
    
    
    
trait Fly{
    
    
    
    
    def fly(){
    
    
    
    
        println("flying")
    
    
    
    
    }
    
    
    
    
    def flywithnowing()
    
    
    
    
}
    
    
    
    

    
    
    
    
trait Walk{
    
    
    
    
    def walk(){
    
    
    
    
        println("walk")
    
    
    
    
    }
    
    
    
    
}
    
    
    
    

    
    
    
    
class Bird{
    
    
    
    
    var name: String= _
    
    
    
    
}
    
    
    
    

    
    
    
    
class BlueBird extends Bird with Fly with Walk{
    
    
    
    
    def flywithnowing(){
    
    
    
    
        println("BlueBird flywithnowing")
    
    
    
    
    }
    
    
    
    
}
    
    
    
    

    
    
    
    
object Test extends App{
    
    
    
    
    val b = new BlueBird()
    
    
    
    
    b.walk()
    
    
    
    
    b.flywithnowing()
    
    
    
    
    b.fly()
    
    
    
    
}
   
   
   
   

10.8 在java.io类库中，你可以通过BufferedInputStream修饰器来给输入流增加缓冲机制。用特质来重新实现缓冲。简单起见，重写read方法

 
 
   
   
   
   

    
    
    
    
import java.io.{InputStream, FileInputStream}
    
    
    
    

    
    
    
    
trait Buffering{
    
    
    
    
    this: InputStream => 
    
    
    
    
    val BUF_SIZE: Int = 5
    
    
    
    
    private val buf = new Array[Byte](BUF_SIZE)
    
    
    
    
    private var bufsize: Int = 0
    
    
    
    
    private var pos: Int = 0
    
    
    
    

    
    
    
    
    override def read(): Int = {
    
    
    
    
        if(pos >= bufsize){
    
    
    
    
            bufsize = this.read(buf, 0, BUF_SIZE)
    
    
    
    
            if(bufsize > 0) -1
    
    
    
    
            pos = 0
    
    
    
    
        }
    
    
    
    
        pos += 1
    
    
    
    
        buf(pos - 1)
    
    
    
    
    }
    
    
    
    
}
    
    
    
    

    
    
    
    
val f = new FileInputStream("test.txt") with Buffering
    
    
    
    

    
    
    
    
for( i <- 1 to 10) println(f.read())
   
   
   
   

10.9 使用本章的日志生成器特质,给前一个练习中的方案增加日志功能，要求体现缓冲的效果

 
 
   
   
   
   

    
    
    
    
import java.io.{InputStream, FileInputStream}
    
    
    
    

    
    
    
    
trait Logger {
    
    
    
    
    def log(msg: String)
    
    
    
    
}
    
    
    
    

    
    
    
    
trait NoneLogger extends Logger {
    
    
    
    
    def log(msg: String) = {}
    
    
    
    
}
    
    
    
    

    
    
    
    
trait PrintLogger extends Logger {
    
    
    
    
    def log(msg: String) = println(msg)
    
    
    
    
}
    
    
    
    
trait Buffering {
    
    
    
    
    this: InputStream with Logger =>
    
    
    
    
    val BUF_SIZE: Int = 5
    
    
    
    
    private val buf = new Array[Byte](BUF_SIZE)
    
    
    
    
    private var bufsize: Int = 0
    
    
    
    
    private var pos: Int = 0
    
    
    
    
    override def read(): Int = {
    
    
    
    
      if (pos >= bufsize) {
    
    
    
    
        bufsize = this.read(buf, 0, BUF_SIZE)
    
    
    
    
        log("buffered %d bytes: %s".format(bufsize, buf.mkString(", ")))
    
    
    
    
        if (bufsize > 0) -1
    
    
    
    
        pos = 0
    
    
    
    
    }
    
    
    
    
      pos += 1
    
    
    
    
      buf(pos-1)
    
    
    
    
  }
    
    
    
    
}
    
    
    
    
val f = new FileInputStream("test.txt") with Buffering with PrintLogger
    
    
    
    
for(i <- 1 to 10) println(f.read())
   
   
   
   

10.10 实现一个IterableInputStream类，扩展java.io.InputStream并混入Iterable[Byte]特质

 
 
   
   
   
   

    
    
    
    

    
    
    
    
trait IterableInputStream extends java.io.InputStream with Iterable[Byte]{
    
    
    
    
    class InputStreamIterator(outer: IterableInputStream) extends Iterator[Byte]{
    
    
    
    
        def hasNext: Boolean = outer.available() > 0 
    
    
    
    
        def next: Byte = outer.read().toByte
    
    
    
    
    }
    
    
    
    

    
    
    
    
    override def iterator: Iterator[Byte] = new InputStreamIterator(this)
    
    
    
    
//    override def read(): Int = 0
    
    
    
    
}
    
    
    
    
val f = new java.io.FileInputStream("test.txt") with IterableInputStream
    
    
    
    

    
    
    
    
for(b <- f) println(b.toChar)