特质(trait)

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

定义

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

语法

定义特质

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

继承特质

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

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

trait作为接口使用

trait作为接口使用，与java的接口使用方法一样。

示例 | 继承单个trait

示例说明

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

参考代码

  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

示例说明

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

参考代码

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

示例说明

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

参考代码

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中还可以定义具体的方法

示例

示例说明

定义一个Logger特质，添加log实现方法
定义一个UserService类，实现Logger特质

添加add方法，打印"添加用户"

添加main方法

创建UserService对象实例
调用add方法

参考代码

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来实现一个日志输出工具，该日志工具可以自动添加日志的日期

步骤

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

创建ConsoleLogger类对象
调用log方法

参考代码

  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、或者更多的需求

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0tNvGQbE-1581825134816)(assets/1557544011845.png)]

定义

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-92o8q76b-1581825134817)(assets/1557543202551.png)]

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

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

示例

示例说明

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

实现步骤

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

参考代码

  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 特质

示例

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

步骤

创建一个Logger特质
- 添加一个log实现方法，打印参数
创建一个UserService类
添加main方法
- 创建UserService对象，混入Logger特质
- 调用log方法

参考代码

  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实现调用链模式

我们如果要开发一个支付功能，往往需要执行一系列的验证才能完成支付。例如：

进行支付签名校验
数据合法性校验
…

如果将来因为第三方接口支付的调整，需要增加更多的校验规则，此时如何不修改之前的校验代码，来实现扩展呢？

责任链模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D3Epq3oY-1581825147908)(assets/1552535142887.png)]

trait调用链

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jtn52DFA-1581825147910)(assets/1557890445726.png)]

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

示例

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PBvP8ZZZ-1581825147910)(assets/1552535850223.png)]

步骤

定义一个HandlerTrait特质
- 定义一个具体的handler方法，打印"处理数据…"
定义一个DataValidHandlerTrait，继承HandlerTrait特质
- 重写handler方法，打印"验证数据"
- 调用父特质的handler方法
定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
- 重写Handler方法
- 打印"检查签名"
- 调用父特质的handler方法
创建一个PaymentService类
- 继承DataValidHandlerTrait
- 继承SignatureValidHandlerTrait
- 定义pay方法
  - 打印"准备支付"
  - 调用父特质的handler方法
添加main方法
- 创建PaymentService对象实例
- 调用pay方法

参考代码

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的构造机制

如果一个类实现了多个trait，那这些trait是如何构造的呢？

定义

trait也有构造代码，但和类不一样，特质不能有构造器参数
每个特质只有**一个无参数**的构造器。
一个类继承另一个类、以及多个trait，当创建该类的实例时，它的构造顺序如下：
1. 执行父类的构造器
2. 从左到右依次执行trait的构造器
3. 如果trait有父trait，先构造父trait，如果多个trait有同样的父trait，则只初始化一次
4. 执行子类构造器

示例

示例说明

定义多个特质，然后用一个类去实现它们
测试trait的构造顺序

步骤

创建一个Logger特质，在构造器中打印"执行Logger构造器!"
创建一个MyLogger特质，继承自Logger特质，，在构造器中打印"执行MyLogger构造器!"
创建一个TimeLogger特质，继承自Logger特质，在构造器中打印"执行TimeLogger构造器!"
创建一个Person类，在构造器中打印"执行Person构造器!"
创建一个Student类，继承自Person、MyLogger、TimeLogge特质，在构造器中打印"执行Student构造器!"
添加main方法，实例化Student_One类，观察输出。

参考代码

trait Logger {
    println("执行Logger构造器")
}

trait MyLogger extends Logger {
    println("执行MyLogger构造器")
}

trait TimeLogger extends Logger {
    println("执行TimeLogger构造器")
}

class Person{
    println("执行Person构造器")
}

class Student extends Person with TimeLogger with MyLogger {
    println("执行Student构造器")
}

def main(args: Array[String]): Unit = {
    new Student
}

// 程序运行输出如下：
// 执行Person构造器
// 执行Logger构造器
// 执行TimeLogger构造器
// 执行MyLogger构造器
// 执行Student构造器

trait继承class

定义

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

示例

示例说明

定义一个特质，继承自一个class

步骤

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

参考代码

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()
}

王傲旗的大数据之路

发布了156 篇原创文章 · 获赞 259 · 访问量 7万+

私信关注

Scala进阶_trait特质(超详细)

特质(trait)

定义

trait作为接口使用

示例 | 继承单个trait

示例 | 继承多个trait

示例 | object继承trait

特质 | 定义具体的方法

示例

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

定义

示例

使用trait实现模板模式

定义

示例

对象混入trait

定义

示例

trait实现调用链模式

责任链模式

trait调用链

示例

trait的构造机制

定义

示例

trait继承class

定义

示例

猜你喜欢