快学Scala第10章----特质

本章要点

  • 类可以实现任意数量的特质
  • 特质可以要求实现它们的类具备特定的字段、方法或超类
  • 和Java接口不同，Scala特质可以提供方法和字段的实现
  • 当你将多个特质叠加在一起时，顺序很重要----其方法先被执行的特质排在更后面

为什么没有多重继承

Scala和Java一样不允许类从多个超类继承；从多了超类继承可能会导致许多问题，例如两个超类有相同的方法，子类该如何使用和菱形继承。在java 中类只能扩展自一个超类，它可以实现任意数量的接口，但接口只能包含抽象方法，不能包含字段。
Scala提供了特质（trait）而非接口。特质可以同时拥有抽象方法和具体方法，而类可以实现多个特质。

当做接口使用的特质

trait Logger {
    def log(msg: String)  // 这是个抽象方法
}

在这里不需要将方法声明为abstract，在特质中，未被实现的方法默认就是抽象的。
子类的实现，使用extends而不是implements

class ConsoleLogger extends Logger {
    def log(msg: String) { println(msg) }
}

在重写特质的抽象方法时不需要给出override关键字。
对于需要多个特质，可以使用with来添加：

class ConsoleLogger extends Logger with Coneable with Serializable

Scala会将 Logger with with Coneable with Serializable首先看成一个整体，然后再由类来扩展。

带有具体实现的特质

在Scala中，特质中的方法并不需要一定是抽象的。

trait ConsoleLogger {
    def log(msg: String)  { println(msg) }
}


class SavingsAccount extends Account with ConsoleLogger {
    def withdraw(amount: Double) {
        if (amount > balance) log("Insufficient funds")
        else banlance -= amount; banlance
    }
}

在Scala中，我们说ConsoleLogger 的功能被“混入”了SavingsAccount 类。但是这样有一个弊端：当特质改变时，所有混入了该特质的类都必须重新编译。

带有特质的对象

在构造单个对象时，你可以为它添加特质：

trait Logged {
    def log(msg: String) { }
}

class SavingsAccount extends Account with Logged {
    def withdraw(amount: Double) {
        if (amount > balance) log("Insufficient funds")
        else ...
    }
    ...
}

现在，什么都不会被记录到日志。但是你可以在构造具体对象时“混入”一个更好的日志记录器的实现

trait ConsoleLogger extends Logged {
    override def log(msg: String) { println(msg) }
}

// 构造SavingsAccount 类对象时加入这个特质
val acct = new SavingsAccount with ConsoleLogger
acct.withdraw(10)   // 此时调用的是 ConsoleLogger 类的log方法

// 另一个对象可以加入不同的特质
val acct2 = new SavingsAccount with FileLogger

叠加在一起的特质

你可以为类或对象添加多个互相调用的特质，从最后一个开始。

trait TimestampLogger extends Logged {
    override def log(msg: String) {
        super.log(new java.util.Date() + " " + msg)
    }
}

trait ShortLogger extends Logged {
    override def log(msg: String) {
        super.log( if (msg.length <= maxLength) msg else msg.substring(0, maxLength - 3)  + "...")
    }
}

对于特质，super.log并不像类那样用于相同的含义，否则就没有什么意义了，因为Logged的log方法什么也没做。实际上，super.log调用的是特质层级中的下一个特质，具体是哪一个，要根据特质添加的顺序来决定。一般来说，特质是从最后一个开始被处理的。例如：

val acct1 = new SavingsAccount with ConsoleLogger with TimestampLogger with ShortLogger
val acct2 = new SavingsAccount with ConsoleLogger with ShortLogger with TimestampLogger

如果从acct1取款，得到的log信息：
Wed Jun 22 23:41:37 CST 2016 Insufficient...
这里是ShortLogger的log方法先被执行，然后它的super.log调用的是TimestampLogger 的log方法，最后调用ConsoleLogger 的方法将信息打印出来
从acct2提款时，输出的log信息
Wed Jun 22 2...
这里先是TimestampLogger 的log方法被执行，然后它的super.log调用的是ShortLogger的log方法，最后调用ConsoleLogger 的方法将信息打印出来。

但是，你可以指定super.log调用哪个特质的方法，使用方式是：

super[ConsoleLogger].log(...) // 这里给出的类型必须是直接超类型，你无法使用继承层级中更远的特质或类

**注意： **ConsoleLogger的log方法没有调用super.log，因此会在这里停止向上传递msg，而是直接打印：

// 改变继承顺序
val acct1 = new SavingsAccountw with TimestampLogger with ConsoleLogger with ShortLoggerval val acct2 = new SavingsAccountw with ShortLogger  with ConsoleLogger with TimestampLoggerval val acct3 = new SavingsAccountw with ShortLogger with TimestampLogger  with ConsoleLogger

// 输出
Insufficient...    // acct1
Thu Jun 23 00:26:20 CST 2016 Insufficient founds   // acct2
Insufficient founds     // acct3

在特质中重写抽象方法

trait Logger {
    def log(msg: String)  // 这是个抽象方法
}

// 扩展这个特质
trait TimestampLogger extends Logger {
    override def log(msg: String) {
        super.log(new java.util.Date() + " " + msg)
    }
}

但是很不幸，这样会报错，因为Logger.log方法还没有实现。但是又和前面一样，我们没有办法知道哪个log方法最终会被调用---这取决于特质被混入的顺序。

Error:(67, 11) method log in trait Logger is accessed from super. It may not be abstract unless it is overridden by a member declared `abstract' and `override'
    super.log(new java.util.Date() + " " + msg)
          ^

Scala认为TimestampLogger 依旧是抽象的，正如错误提示，它需要一个具体的log方法，你必须给方法打上abstract关键字和override关键字，以说明它也是个抽象方法：

trait TimestampLogger extends Logger {
   abstract override def log(msg: String) {
        super.log(new java.util.Date() + " " + msg)
    }
}

这样会按照继承层级，一直到一个具体的log方法。

当做富接口使用的特质

在Scala中可以在特质中使用具体和抽两方法：

trait Logger {
    def log(msg: String)
    def info(msg: String) { log("INFO: " + msg) }
    def warn(msg: String) { log("WARN: " + msg) }
    def severe(msg: String) {log("SEVERE: " + msg)}
}

class SavingsAccount extends Account with Logger {
    def withdraw(amount: Double) {
        if (amount > balance) severe("Insufficient funds")
        else ...
    }
    override def log(msg: String) { println(msg) }
}

特质中的具体字段

特质中的字段有初始值则就是具体的，否则是抽象的。

trait ShortLogger extends Logged {
  val maxLength = 15   // 具体字段
}

那么继承该特质的子类是如何获得这个字段的呢。Scala是直接将该字段放入到继承该特制的子类中，而不是被继承。例如：

class SavingsAccount extends Account with ConsoleLogger with ShortLogger {
  var interest = 0.0
  def withdraw(amount: Double) {
    if (amount > balance) log("Insufficient funds")
    else ...
  }
}

SavingsAccount 对象由所有超类的字段和任何它自己的类中定义的字段构成：

| balance | // 超类字段
|-----------|
| interest | // 子类字段
| maxLength |

在JVM中，一个类只能扩展一个超类，因此来自特质的字段不能以相同的方式继承。

特质中的抽象字段

特质中的抽象字段在具体的子类中必须被重写:

trait ShortLogger extends Logged {
  val maxLength: Int
  override def log(msg: String) {
    super.log( if (msg.length <= maxLength) msg else msg.substring(0, maxLength - 3)  + "...")
  }
}

class SavingsAccount extends Account with ConsoleLogger with ShortLogger {
  val maxLength = 20   // 不需要写override
}

为了在构造对象是灵活使用特质参数值，可以使用带有具体实现的特质：

class SavingsAccount extends Account with Logger { ... }

val acct = new SavingsAccount with ConsoleLogger with ShortLogger {
  val maxLength = 20
}

特质构造顺序

特质也是有构造器的，由字段的初始化和其他特质体中的语句构成：

trait FileLogger extends Logger {
  val out = new PrintWriter("app.log")     // 构造器的一部分
  out.println("# " + new Date().toString)  // 也是构造器的一部分

  def log(msg: String) { out.println(msg); out.flush() }
}

这些语句在任何混入了该特质的对象在构造时都会被执行。
构造器的顺序：

  • 首先调用超类的构造器
  • 特质构造器在超类构造器之后、类构造器之前执行
  • 特质由左到右被构造
  • 每个特质中，父特质先被构造
  • 如果多个特质共有一个父特质，那么那个父特质已经被构造，则不会被再次构造
  • 所有特质构造完毕后，子类被构造。
    例如：
class SavingsAccount extends Account with FileLogger with ShortLogger

构造器执行顺序：

  1. Account （超类）
  2. Logger (第一个特质的父特质)
  3. FileLogger
  4. ShortLogger
  5. SavingsAccount

初始化特质中的字段

特质不能有构造器参数，每个特质都有一个无参构造器。这也是特质和类的唯一的技术差别。除此之外，特质可以具备类的所有特性，比如具体的和抽象的字段，以及超类。
例如： 我们要在构造的时候指定log的输出文件：

trait FileLogger extends Logger {
  val filename: String                            // 构造器一部分
  val out = new PrintWriter(filename)     // 构造器的一部分
  def log(msg: String) { out.println(msg); out.flush() }
}

val acct = new SavingsAccount extends Account with FileLogger("myapp.log")  //error，特质没有带参数的构造器

// 你也许会想到和前面重写maxLength一样，在这里重写filename:
val acct = new SavingsAccount with FileLogger {
  val filename = "myapp.log"   // 这样是行不通的
}

上述问题出在构造顺序上。是否还记得在第8章中提到的构造顺序的问题，在这里也是一样的。FileLogger的构造器先于子类构造器执行。这里的子类其实是一个扩展自SavingsAccount 并混入了FileLogger特质的匿名类。而filename的初始化发生在这个匿名类中，而FileLogger的构造器会先执行，因此new PrintWriter(filename)语句会抛出一个异常。
解决方法也是要么使用提前定义或者使用懒值：

val acct = new {
  val filename = "myapp.log"
} with SavingsAccount with FileLogger

// 对于类同样：
class SavingsAccount extends {
  val filename = "myapp.log"
} with Account with FileLogger { 
  ...   // SavingsAccount 的实现
}

// 或使用lazy
trait FileLogger extends Logger {
  val filename: String                            // 构造器一部分
  lazy val out = new PrintWriter(filename)     // 构造器的一部分
  def log(msg: String) { out.println(msg); out.flush() }
}

扩展类的特质

特质也可以扩展类，这个类将会自动成为所有混入该特质的超类

trait LoggedException extends Exception with Logged {
  def log() { log(getMessage()) }
}

log方法调用了从Exception超类继承下来的getMessage 方法。那么混入该特质的类：

class UnhappyException extends LoggedException {
  override def getMessage() = "arggh!"
}

在这里LoggedException的超类Exception 也自动成了UnhappyException 的超类，所以可以重写getMessage方法。如图：


trait.png

另一种情况：子类已经扩展了另一个类怎么办，以为只能有一个超类。在Scala中，只要子类已经扩展的类是那个特质的超类的一个子类即可。例如：

class UnhappyException extends IOException with LoggedException  // right
class UnhappyException extends JFrame with LoggedException         // error

自身类型

在上面提到的，当特质扩展类时，编译器能够确保的一件事是所有混入该特质的类都认这个类做超类。Scala还有一套机制可以保证这一点：自身类型。
当特质以如下代码开始定义时：

this: 类型 =>    // 表明只能被混入指定类型的子类

trait LoggedException extends Logged {
  this: Exception =>
    def log() { log(getMessage()) }
}

注意该特质并没有扩展Exception类，而是有一个自身类型Exception。这意味着它只能被混入Exception的子类。
在某种情况下，自身类型比超类型版的特质更灵活，如在特质间的循环依赖时。自身类型也用样可以处理结构类型--只需要给出类必须用有的方法，而不是类名称。

trait LoggedException extends Logged {
  this: { def getMessage(): String } =>
    def log() { lgo(getMessage() ) }  
}

背后的故事

Scala需要将特质翻译称JVM的类和接口。只有抽象方法的特质被简单的变成一个Java接口:

trait Logger {
  def log(msg: String)
}

// 直接被翻译成：
public interface Logger {
  void log(String msg);
}

如果特质有具体的方法，Scala会自动创建一个伴生类，该伴生类用静态方法存放特质的方法：

trait ConsoleLogger extends Logger {
  def log(msg: String) { println(msg) }
}

// 被翻译成：
public interface ConsoleLogger extends Logger {
  void log(String msg);
}
// 伴生类
public class ConsoleLogger$class {
  public static void log(ConsoleLogger self, String name) {
    println(msg)
  }
  ...
}

这些半生类不会有任何字段。特质中的字段对应到接口中的抽象的getter和setter方法。

trait ShortLogger extends Logger {
  val maxLength = 15
}

// 被翻译成：
public interface ShortLogger extends Logger {
  public abstract int maxLength();
  public abstract void weird_prefix$maxLength_$eq(int);  // 以weird开头的setter方法
  ...
}

// 初始化发生在半生类的一个初始化方法内
public class ShortLogged$class {
  public void $init$(ShortLogger self) {
    self.weird_prefix$maxLength_$eq(15)
  }
}

但是当ShortLogger 被混入类的时候，类将会得到一个带有getter和setter的maxLength字段，该类的构造器会调用初始化方法。
如果特质扩展自某个超类，则伴生类并不继承这个超类。该超类会被前面提到过的，任何实现该特质的类继承。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,242评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,769评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,484评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,133评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,007评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,080评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,496评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,190评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,464评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,549评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,330评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,205评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,567评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,889评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,160评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,475评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,650评论 2赞 335

推荐阅读更多精彩内容

  • Scala 摘要
    读《快学Scala 》一书的摘要 Scala 运行于JVM之上，拥有海量类库和工具，兼顾函数式编程和面向对象。 在...
    abel_cao阅读 1,269评论 0赞 8
  • Scala vs Java8
    这篇讲义只讲scala的简单使用，目的是使各位新来的同事能够首先看懂程序，因为 scala 有的语法对于之前使用习...
    MrRobot阅读 2,890评论 0赞 10
  • scala 入门学习
    Scala学习笔记： 1.1 scala的基础语法 声明与定义（赋值）:声明变量时可以指定类型，不指定也可以自动识...
    哎哟喂喽阅读 553评论 0赞 2
  • 月季飘香
    panda潘达阅读 788评论 57赞 48
  • 学以致用的重要性-这样读书就够了
    2016年是我学习的一个飞跃的阶段，接触了好多以前没有接触的东西，时间管理，思维导图，快速阅读，我变得异常兴奋，开...
    阳光小花阅读 2,560评论 0赞 0