Scala之通俗易懂理解动态混入与叠加特质

scala动态混入

动态混入就是在不修改原代码的情况下扩展功能

package top.mgy.scalaTest


object Dome02 {
  def main(args: Array[String]): Unit = {
    //动态混入，在不修改代码的情况下扩展功能
    //可以看到在OracleDB中没有任何方法的情况下，动态混入了Operate即拥有了 insert方法
    val oracle = new OracleDB with Operate
    oracle.insert(10)

    val mysql = new MysqlDB with Operate
    mysql.insert(100)

    /**
      * 即使在有没有实现的方法上也可以使用动态混入
      */
    val mysql_ = new MysqlDB_ with Operate {
      override def say(): Unit = {
        println("say")
      }
    }
    mysql_.insert(100)
    mysql_.say()
  }
}

trait Operate{
  def insert(num:Int): Unit ={
    println("插入数据:"+num)
  }
}

class OracleDB{
}

abstract class MysqlDB{

}

abstract class MysqlDB_{
  def say()
}

叠加特质

构建对象的同时如果混入多个特质，称之为叠加特质，那么特质声明顺序是从左往右，方法的执行顺序是从右往左。

package top.mgy.scalaTest

object Dome03 {
  def main(args: Array[String]): Unit = {

    //创建msql4示时，动态混入了 DB4 File4
    //问题1  Mysql4 的构建过程如何
      // 从左向右依次构建
      // 首先构建mysql4  然后构建混入的DB4,但是DB4 继承了 Data4 所以找到 Data4 ，Data4又继承了 Operate4 再找 Operate4
     // 然后在构建 File4,但是发现 File4 的父路线已经构建完成，所以就不会再构建了
     // 然后执行输出  Operate4  Data4  DB4  File4
    val mysql = new Mysql4 with DB4 with File4
    //方法执行的顺序   从右向左执行
    //即执行输出
    //向文件   后面调用了super，但是并不是执行的其所继承的 Data4的方法而是 DB4的insert，因为是动态混入所以super也是动态的
    //向数据库
    //插入数据 = 100
    //执行顺序规则: (1) 从左到右执行  (2) 当执行到super时，super是指左边的特征 (3) 如何左边没有特质了，则执行自己继承的特质
    mysql.insert(100)
  }
}


trait Operate4{
  println("Operate4")
  def insert(id:Int) //抽象方法
}

trait Data4 extends Operate4{
  println("Data4")

  override def insert(id: Int): Unit = {
    println("插入数据 = " + id)
  }
}

trait DB4 extends Data4 {
  println("DB4")

  override def insert(id: Int): Unit = {
    println("向数据库")
    super.insert(id)
  }
}

trait File4 extends Data4 {
  println("File4")

  override def insert(id: Int): Unit = {
    println("向文件")
    super.insert(id)
  }

}
class Mysql4{}