接口概念（Java回顾）

在 Java 中有接口的概念
定义接口：interface 接口名
实现接口：class 类名 implements 接口名1, 接口名2
使用小结：

  • 一个类可以实现多个接口
  • 接口之间支持多继承
  • 接口中属性都是常量
  • 接口中方法都是抽象的

特质介绍

在 Scala 中，当有多个类有相同的特征时，可以将这些特征（特质）独立出来，采用关键字 trait 声明
作用：代替 Java 的接口；是对 Scala 单继承机制的一种补充
理解：特质相当于 Java 中的 interface + abstract class
注意：特质名一般首字母大写**

  1. // 语法
  2. trait 特质名 { 
  3.   // trait体 
  4. }
  6. // 使用
  7. // 方式一：没有父类
  8. class 类名 extends Trait1 with Trait2 ...
  9. // 方法二：有父类
  10. class 类名 extends 父类 with Trait1 with Trait2 ...

案例研究

  1. // 自行测试
  2. object Test {
  3.   def main(args: Array[String]): Unit = {
  4.     val b = new B
  5.     b.getConnection()
  6.     println(b.getUser(100))
  7.   }
  8. }
  10. // 定义一个特质
  11. trait Driver {
  12.   // 抽象方法
  13.   def getConnection()
  14.   // 具体方法（即非抽象方法）
  15.   def getUser(id: Int): String = s"得到 id 为 ${id} 的用户数据"
  16. }
  18. class A {}
  19. class B extends A with Driver {
  20.   override def getConnection(): Unit = println("连接MySQL数据库")
  21. }

📝 说明

  • 特质可以包含抽象方法和非抽象方法；这两种方法都有的特质称为富接口
  • 一个类通过 extends 继承一个特质或父类，通过 with 关键字继承多个特质
  • 所有的 Java 接口都可以当做 Scala 的特质使用

    动态混入

    使用特质有两种方式：
  1. 在声明类时继承特质
  2. 在创建对象时混入特质（即动态混入，这是 Scala 特有的方式）

优点：可以在不修改类定义的情况下，扩展目标类的功能，非常灵活，耦合性低
注意：抽象类动态混入特质时还需要通过创建匿名子类对象的方式实现抽象方法

  1. object TraitDemo {
  2.   def main(args: Array[String]): Unit = {
  3.     // 类混入特质
  4.     val mysql = new Mysql with Driver
  5.     mysql.insert("mysql", 99)
  7.     // 抽象类混入特质（还需要实现抽象方法）
  8.     val oracle = new Oracle with Driver {
  9.       override def say(): Unit = println("这个数据库是Oracle")
  10.     }
  11.     oracle.insert("oracle", 11)
  12.     oracle.say()
  14.     val mongodb = new Mongodb
  15.     mongodb.insert("mongodb", 22)
  16.   }
  17. }
  19. trait Driver {
  20.   def insert(db: String, id: Int): Unit = {
  21.     println(db + " :插入数据的id为 " + id)
  22.   }
  23. }
  25. class Mysql {}
  26. abstract class Oracle {
  27.   def say()
  28. }
  29. // 一个类直接继承一个特质
  30. class Mongodb extends Driver {}

叠加特质

定义：创建对象的同时如果混入多个特质，称为叠加特质
顺序：特质声明顺序从左往右，构建顺序从左往右，方法执行顺序从右往左⭐

  1. // 自行测试
  2. object Test {
  3.   def main(args: Array[String]): Unit = {
  4.     val p = new Person with Trait3 with Trait4
  5.     p.showInfo(123)
  6.   }
  7. }
  9. trait Trait1 {
  10.   println("Trait1 ...")
  11.   def showInfo(id: Int)
  12. }
  14. trait Trait2 extends Trait1 {
  15.   println("Trait2 ...")
  16.   // 重写/实现抽象方法
  17.   def showInfo(id: Int): Unit = {
  18.     println("Trait2的id：" + id)
  19.   }
  20. }
  22. trait Trait3 extends Trait2 {
  23.   println("Trait3 ...")
  24.   // 重写方法
  25.   override def showInfo(id: Int): Unit = {
  26.     println("Trait3 调用 Trait2 的方法")
  27.     super.showInfo(id + 2)
  28.   }
  29. }
  31. trait Trait4 extends Trait2 {
  32.   println("Trait4 ...")
  33.   // 重写方法
  34.   override def showInfo(id: Int): Unit = {
  35.     println("Trait4 调用 Trait2 的方法")
  36.     super.showInfo(id)
  37.     super[Trait2].showInfo(id)
  38.   }
  39. }
  41. class Person {
  42.   println("Person ...")
  43. }

📝 执行结果

  1. // 构建顺序
  2. Person ...
  3. Trait1 ...
  4. Trait2 ...
  5. Trait3 ...
  6. Trait4 ...
  7. // 执行顺序
  8. Trait4 调用 Trait2 的方法
  9. Trait3 调用 Trait2 的方法
  10. Trait2的id：125
  11. Trait2的id：123

📝 详细说明

  • 动态混入时，如果特质中使用了 super 关键字，并不是调用了父特质的方法，而是向左边继续查找特质，找不到才会去父特质查找
  • 如果想要调用具体方法的特质，可以指定：super[特质].xxx()【注意泛型必须是该特质的直接超类类型】

    ✍ 思考题

    目前为止，在 Scala 中创建对象共有几种方式？
  1. 使用 new 关键字创建
  2. 通过 apply 方式创建
  3. 使用匿名子类创建
  4. 使用动态混入创建