Scala--特质

 

一、为什么没有多重继承

c++允许多重继承

Java不允许多重继承，类只能继承一个超类，可以实现任意数量的接口。

 

如何继承这两个抽象基类？

Scala提供“特质”而非接口；特质可以同时抽象方法和具体方法。类可以实现多个特质。

 

二、当做接口使用的特质

  trait Logger{
    def log(msg: String)
  }

  class ConsoleLogger extends Logger{   //使用 extends 不能使用 implements

    def log(msg: String): Unit ={     // 不需要使用override
      println(msg)
    }
  }

 

三、带有具体实现的特质

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

  class SavingAccount extends Logger{
    def display(msg: String): Unit ={
      log(msg)
    }
  }

  val v = new SavingAccount()
  v.display("Hello")

 

注：特质发生变化，所有混入特质的类都需要重新编译。

四、带有特质的对象

  trait Logged{
    def log(msg: String){}     //特质，方法是个空实现
  }

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

  class SavingAccount extends Logged{  //类继承特质，方法的实现结果为空
    def display(msg:String){log(msg)
    }
  }

  val s = new SavingAccount()        //构造对象，结果为空
  s.display("Hello")

  val s1 = new SavingAccount() with ConsoleLogger //在构造对象的时候，加入特质，结果为 Hello
  s1.display("Hello")

 

五、叠加在一起的特质

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

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

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

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

  class SavingAccount extends Logged {
    def display(msg: String) {
      log(msg)
    }
  }

  val s = new SavingAccount with ConsoleLogger with TimestampLogger with ShortLogger //ShortLogger的log方法先执行，然后是 TimestampLogger
  s.display("Hello")

  val s1 = new SavingAccount with ConsoleLogger with ShortLogger with TimestampLogger //TimeStampLogger的方法先执行，然后是 ShortLogger
  s1.display("Hello")

结果：

Wed Aug 31 23:27:53 CST 2016 Hello
Wed Aug 31 2...

 

六、在特质中重写抽象方法

    trait Logged{
      def log(msg: String)
    }

    trait ConsoleLogger extends Logged{
      override def log(msg: String) {println(msg)}
    }
    trait TimestampLogger extends Logged{
      abstract override def log(msg: String){   //继承抽象方法，需要使用abstract关键字，对抽象方法进行重写
        super.log(new java.util.Date() + " " + msg)
      }
    }

    class SavingAccount extends ConsoleLogger {
      def display(msg: String) {
        log(msg)
      }
    }

    val s = new SavingAccount with TimestampLogger
    s.display("Hello")

结果：

Wed Aug 31 23:51:40 CST 2016 Hello

 

七、当做富接口使用的特质

    trait Logged{                           // 特质将抽象方法，和具体方法结合在一起
      def log(msg: String)
      def info(msg: String){log(msg)}
      def warn(msg: String){log(msg)}
    }

    trait ConsoleLogger extends Logged{
      override def log(msg: String) {println(msg)}
    }
    trait TimestampLogger extends Logged{
      abstract override def log(msg: String){   //继承抽象方法，需要使用abstract关键字，对抽象方法进行重写
        super.log(new java.util.Date() + " " + msg)
      }
    }

    class SavingAccount extends ConsoleLogger {
      def display(msg: String) {
        info(msg)
      }
    }

    val s = new SavingAccount with TimestampLogger
    s.display("Hello")

结果：

Thu Sep 01 09:38:54 CST 2016 Hello

 

八、特质中的具体字段

在子类中添加特质，特质中的字段就相当于子类中的字段

 

九、特质中的抽象字段

 特质中的抽象字段，在子类的具体实现中必须要被重写

    trait Logged{                           // 特质将抽象方法，和具体方法结合在一起
      val maxLength: Int                    // 抽象字段
      def log(msg: String)
      def info(msg: String){log(msg)}
      def warn(msg: String){log(msg)}
    }

    trait ConsoleLogger extends Logged{
      override def log(msg: String) {println(msg)}
    }
    trait TimestampLogger extends Logged{
      abstract override def log(msg: String){   //继承抽象方法，需要使用abstract关键字，对抽象方法进行重写
        super.log(new java.util.Date() + " " + msg)
      }
    }

    class SavingAccount(val maxLength: Int) extends ConsoleLogger { //抽象字段当做参数传递
      //val maxLength = 20        //抽象字段在类中被重写
      def display(msg: String) {
        info(msg)
        info(maxLength.toString)
      }
    }

    val s = new SavingAccount(20)  with TimestampLogger //传递参数
    s.display("Hello")

结果：

Thu Sep 01 10:05:55 CST 2016 Hello
Thu Sep 01 10:05:55 CST 2016 20

 

十、特质构造顺序

1、首先调用超类的构造器

2、然后调用特质构造器，特质构造器在超类构造器之后，类构造器之前

3、特质由左到右被构造

4、在每个特质当中，父特质先被构造

5、如果多个特质公用一个父特质，而那个父特质已经被构造过了，则不会再被构造

6、所有特质构造完毕，子类被构造

例子:

class SavingAccount extends Account with FileLogger with ShortLogger

构造器执行顺序：

1、Account(超类)

2、Logger(第一个特质的父特质)

3、FileLogger(第一个特质)

4、ShortLogger(第二个特质)

5、SavingAccount(类)

 

特质方法Super被解析的顺序 从右向左

ShortLogger(super)->FileLogger(super)->Logger

 

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

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

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

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

  class SavingAccount extends Logged {
    def display(msg: String) {
      log(msg)
    }
  }

  val s = new SavingAccount with ConsoleLogger with TimestampLogger with ShortLogger
  s.display("Hello")

  val s1 = new SavingAccount with ConsoleLogger with ShortLogger with TimestampLogger
  s1.display("Hello")

结果：

This is ShortLogger
This is TimestampLogger
Thu Sep 01 13:55:33 CST 2016 Hello
This is TimestampLogger
This is ShortLogger
Thu Sep 01 1...

 

十一、初始化特质中的字段

特质中不能使用构造参数

要想初始化特质中的字段，可使用如下方式：

1、提前定义，在特质的构造函数之前定义

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

  trait FileLogger extends Logger{
    val filename: String
    val out = new PrintWriter(filename)
    override def log(msg: String) {
      out.println(msg)
      out.flush()
    }
  }

  class SavingAccount extends Logger{
    def display(msg: String): Unit ={
      log(msg)
    }
  }//val c = new SavingAccount with FileLogger{ val filename="mylog.txt" } //构造器运行在 FileLogger构造器之后，所以不会运行成功
  val c = new {val filename = "mylog.txt"} with SavingAccount with FileLogger //这里使用了提前定义，可以正确执行

  c.display("hello11")

 

2、使用lazy值

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

  trait FileLogger extends Logger{
    val filename: String
    lazy val out = new PrintWriter(filename)  //使用懒值 out 在使用时，才会初始化，那时filename值已经被正确设置了
    override def log(msg: String) {
      out.println(msg)
      out.flush()
    }
  }

  class SavingAccount extends Logger{
    def display(msg: String): Unit ={
      log(msg)
    }
  }//val c = new SavingAccount with FileLogger{ val filename="mylog.txt" } //构造器运行在 FileLogger构造器之后，所以不会运行成功
  //val c = new {val filename = "mylog.txt"} with SavingAccount with FileLogger //这里使用了提前定义，可以正确执行
  val c = new SavingAccount with FileLogger { val filename="mylog.txt" }

  c.display("hello world")

懒值在每次使用前都会检查是否已经初始化，用起来并不是那么高效

 

3、使用类主构造器传参

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

  trait FileLogger extends Logger{
    val filename: String
    //lazy val out = new PrintWriter(filename)  //使用懒值 out 在使用时，才会初始化，那时filename值已经被正确设置了
    val out = new PrintWriter(filename)
    override def log(msg: String) {
      out.println(msg)
      out.flush()
    }
  }

//  class SavingAccount extends Logger{
//    def display(msg: String): Unit ={
//      log(msg)
//    }
//  }

  class SavingAccount(val filename: String) extends Logger{
    def display(msg: String): Unit ={
      log(msg)
    }
  }

  //val c = new SavingAccount with FileLogger{ val filename="mylog.txt" } //构造器运行在 FileLogger构造器之后，所以不会运行成功
  //val c = new {val filename = "mylog.txt"} with SavingAccount with FileLogger //这里使用了提前定义，可以正确执行
  //val c = new SavingAccount with FileLogger { val filename="mylog.txt" }
  val c = new SavingAccount("mylog.txt") with FileLogger

  c.display("hello world 111")

 

十二、扩展类的特质

特质可以扩展另一个特质，特质也可以扩展类

类扩展了特质，特质扩展了类，特质的超类成为我们类的超类；

如果类扩展了另一个类，只要那个类是特质超类的子类就可以。

如果扩展多个类，且是不相干的，类不能有多个超类

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

  trait LoggedException extends Exception with Logged{ //特质扩展超类
      def log() {log(getMessage())}
  }

  class UnhappyException extends LoggedException{  //类扩展特质,特质的超类Exception 也成为了类UnHappyException的超类
    override def getMessage() = "aaa"
  }

  class UnhappyException extends IOException with LoggedException //可以扩展 IOException是 Exception的子类

  class UnhappyException extends JFrame with LoggedException // JFrame 和 Exception 没继承关系 不能扩展

 

十三、自身类型

this : Exception =>

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

    trait LoggedException extends Logged{ //特质扩展超类
        this: Exception =>             //自身类型  自身类型为Exception，它只能被混入Exception的子类
        def log() {log(getMessage())}
    }

    val f = new JFrame with LoggedException //错误 JFrame不是 Exception的子类型，而Exception是LoggedException的自身类型

 

结构类型：

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

  trait LoggedException extends Logged{   //特质扩展超类
    this: {def getMessage():String} =>     //自身类型（结构类型） 这个特质可以被混入任何拥有getMessage方法的类
    def log() {log(getMessage())}
  }

 

十四、背后发生了什么

 

 

 

参考《快学Scala》