Scala 034 特质trait

Scala 特质trait

scala中没有Java中的接口（interface），替代的概念是——特质

• 特质是scala中代码复用的基础单元
• 它可以将方法和字段定义封装起来，然后添加到类中
• 与类继承不一样的是，类继承要求每个类都只能继承一个超类，而一个类可以添加任意数量的特质。
• 特质的定义和抽象类的定义很像，但它是使用trait关键字

语法：定义trait

trait 名称 {
    // 抽象字段
    // 抽象方法
}

语法：继承trait

class 类 extends 特质1 with 特质2 {
    // 字段实现
    // 方法实现
}

• 使用extends来继承trait（scala不论是类还是特质，都是使用extends关键字）
• 如果要继承多个trait，则使用with关键字

trait作为接口使用

例如：继承单个trait
1.创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
2.创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
3.添加main方法，创建ConsoleLogger对象，调用log方法

package demo02

object Scala22 {
  trait Logger {
    // 抽象方法
    def log(message:String)
  }

  class ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台日志:" + message)
  }

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("这是一条日志")
  }
}

例如：继承多个trait

1. 创建一个MessageSender特质，添加send方法
2. 创建一个MessageReceiver特质，添加receive方法
3. 创建一个MessageWorker实现这两个特质
4. 在main中调用，分别调用send方法、receive方法

package demo02

object Scala23 {

  trait MessageSender {
    def send(msg: String)
  }

  trait MessageReceive {
    def receive(): String
  }

  class MessageWorker extends MessageSender with MessageReceive {
    override def send(msg: String): Unit = println(s"发送消息:${msg}")

    override def receive(): String = "你好！我叫一个好人！"
  }

  def main(args: Array[String]): Unit = {
    val worker = new MessageWorker
    worker.send("hello")
    println(worker.receive())
  }
}

例如：object继承trait

1. 创建一个Logger特质，添加一个log抽象方法
2. 创建一个ConsoleLogger的object，实现LoggerForObject特质，实现log方法，打印消息
3. 编写main方法，调用ConsoleLogger的log方法

package demo02

object Scala24 {
  trait Logger {
    def log(message:String)
  }

  object ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台消息:" + message)
  }

  def main(args: Array[String]): Unit = {
    ConsoleLogger.log("程序退出!")
  }
}

trait中还可以定义具体的方法

例如：

1. 定义一个Logger特质，添加log实现方法
2. 定义一个UserService类，实现Logger特质
3. 添加add方法，打印"添加用户"
4. 添加main方法
5. 创建UserService对象实例
6. 调用add方法

package demo02

trait LoggerDetail {
  // 在trait中定义具体方法
  def log(msg:String) = println(msg)
}

class UserService extends LoggerDetail {
  def add() = log("添加用户")
}

object MethodInTrait {
  def main(args: Array[String]): Unit = {
    val userService = new UserService
    userService.add()
  }
}

trait中定义具体的字段和抽象的字段

• 在trait中可以定义具体字段和抽象字段
• 继承trait的子类自动拥有trait中定义的字段
• 字段直接被添加到子类中

例如：通过trait来实现一个日志输出工具，该日志工具可以自动添加日志的日期

1. 创建Logger特质
2. 定义一个SimpleDateFormat字段，用来格式化日期（显示到时间）
3. 定义一个TYPE抽象字段，用于定义输出的信息
4. 创建一个log抽象方法，用于输出日志
5. 创建ConsoleLogger类，实现TYPE抽象字段和log方法
6. 添加main方法
7. 创建ConsoleLogger类对象
8. 调用log方法

package demo02

import java.text.SimpleDateFormat
import java.util.Date

object Scala26 {
  trait Logger {
    val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
    def log(msg:String)
  }

  class ConsoleLogger extends Logger {
    override def log(msg: String): Unit = {
      val info = s"${sdf.format(new Date())}:控制台消息:${msg}"
      println(info)
    }
  }

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger()
    logger.log("NullPointerException")
  }
}

使用trait实现模板模式

要实现以下需求：

• 实现一个输出日志的功能
• 目前要求输出到控制台
• 将来可能会输出到文件、输出到Redis、或者更多的需求

如何实现将来不修改之前的代码，来扩展现有功能呢？

在一个特质中，具体方法依赖于抽象方法，而抽象方法可以放到继承trait的子类中实现，这种设计方式也称为模板模式。

在scala中，trait是可以定义抽象方法，也可以定义具体方法的

• trait中定义了一个抽象方法
• trait中定义了其他的几个具体方法，会调用抽象方法
• 其他实现类可以来实现抽象方法
• 真正调用trait中具体方法的时候，其实会调用实现类的抽象方法实现

例如：编写一个日志输出工具，分别有info、warn、error三个级别的日志输出，日志输出的方式要求设计为可扩展的，例如：可以输出到控制台、将来也可以扩展输出到文件、数据库等

1. 添加一个Logger特质
2. 添加一个log抽象方法
3. 添加一个info、warn、error具体方法，这几个方法调用log抽象方法
4. 创建ConsoleLogger类，实现Logger特质
5. 添加main方法
6. 创建ConsoleLogger类对象
7. 分别调用info、warn、error方法输出日志

package demo02

object Scala27 {
  trait Logger {
    def log(msg:String)
    def info(msg:String) = log("INFO:" + msg)
    def warn(msg:String) = log("WARN:" + msg)
    def error(msg:String) = log("ERROR:" + msg)
  }

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

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.info("信息日志")
    logger.warn("警告日志")
    logger.error("错误日志")
  }
}

对象混入trait

scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中

语法：

val/var 对象名 = new 类 with 特质

例如：给一个对象添加一些额外的行为

1. 创建一个Logger特质
2. 添加一个log实现方法，打印参数
3. 创建一个UserService类
4. 添加main方法
5. 创建UserService对象，混入Logger特质
6. 调用log方法

package demo02

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

  class UserService

  def main(args: Array[String]): Unit = {
    val service = new UserService with Logger
    service.log("混入的方法")
  }
}

trait实现调用链模式

我们如果要开发一个支付功能，往往需要执行一系列的验证才能完成支付。例如：
1.进行支付签名校验
2.数据合法性校验
3…
如果将来因为第三方接口支付的调整，需要增加更多的校验规则，此时如何不修改之前的校验代码，来实现扩展呢？

责任链模式

trait调用链

类继承了多个trait后，可以依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。

例如：实现一个模拟支付过程的调用链

1. 定义一个HandlerTrait特质
2. 定义一个具体的handler方法，打印"处理数据…"
3. 定义一个DataValidHandlerTrait，继承HandlerTrait特质
4. 重写handler方法，打印"验证数据"
5. 调用父特质的handler方法
6. 定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
7. 重写Handler方法
8. 打印"检查签名"
9. 调用父特质的handler方法
10. 创建一个PaymentService类
11. 继承DataValidHandlerTrait
12. 继承SignatureValidHandlerTrait
13. 定义pay方法
14. 打印"准备支付"
15. 调用父特质的handler方法
16. 添加main方法
17. 创建PaymentService对象实例
18. 调用pay方法

package demo02

object Scala29 {

  trait HandlerTrait {
    def handle(data: String) = println("处理数据...")
  }

  trait DataValidHanlderTrait extends HandlerTrait {
    override def handle(data: String): Unit = {
      println("验证数据...")
      super.handle(data)
    }
  }

  trait SignatureValidHandlerTrait extends HandlerTrait {
    override def handle(data: String): Unit = {
      println("校验签名...")
      super.handle(data)
    }
  }

  class PayService extends DataValidHanlderTrait with SignatureValidHandlerTrait {
    override def handle(data: String): Unit = {
      println("准备支付...")
      super.handle(data)
    }
  }

  def main(args: Array[String]): Unit = {
    val service = new PayService
    service.handle("支付参数")
  }
}
//程序运行输出如下：
//准备支付...
//检查签名...
//验证数据...
//处理数据...

trait继承class

trait也可以继承class。特质会将class中的成员都继承下来。

例如：定义一个特质，继承自一个class

1. 创建一个MyUtils类，定义printMsg方法
2. 创建一个Logger特质，继承自MyUtils，定义log方法
3. 创建一个Person类，添加name字段
4. 继承Logger特质
5. 实现sayHello方法，调用log方法
6. 添加main方法，创建一个Person对象，调用sayHello方法

package demo02

object Scala30 {

  class MyUtil {
    def printMsg(msg: String) = println(msg)
  }

  trait Logger extends MyUtil {
    def log(msg: String) = printMsg("Logger:" + msg)
  }

  class Person extends Logger {
    def sayHello() = log("你好")
  }

  def main(args: Array[String]): Unit = {
    val person = new Person
    person.sayHello()
  }
}