scala之-初始化对象时动态混入叠加特质 new C() with T1 withT2 ..

scala之-初始化对象时动态混入叠加特质

• extends with with with …

 * 在动态混入叠加特质的时候，如果特质中调用super.insert(i)，
 * 那么这个super首先会调用左边特质的insert(i)，而不一定是父类的。
 * 只有当当前特质的左边没有特质的时候，或者左边特质没有该方法时才会调用该特质的父类的insert(i)
 *
 * 叠加特质的声明：从左往右 new C1() with T1 with T2 ....
 * 叠加特质执行super.xx：从右往左执行，
 * 初始化一个类的实例时，会递归先调用父类的构造器（只要是在构造器中的变量、成员都会被初始化。），与Java一样！

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

    /**
     * 在动态混入叠加特质的时候，如果特质中调用super.insert(i)，
     * 那么这个super首先会调用左边特质的insert(i)，而不一定是父类的。
     * 只有当当前特质的左边没有特质的时候，才会调用该特质的父类的insert(i)
     *
     * 叠加特质的声明：从左往右 new C1() with T1 with T2 ....
     * 叠加特质执行super.xx：从右往左执行，
     * 初始化一个类的实例时，会递归先调用父类的构造器（只要是在构造器中的变量、成员都会被初始化。），与Java一样！
     */
    /**
     *
    T1
    T2
    T3
    T4
    (插入数据 ,1)
     */
    val c = new C() with T3 with T4
    c.insert(1)

    //    val c1: C1 with T3 with T4 = new C1 with T3 with T4 {
    //      override def say(): Unit = ???
    //    }
    //
    //    c1.insert(100)
    //    c1.say()
  }
}

//声明一个类,到时候用来动态混入特质，抽象类也可以在实例化的时候动态混入特质
class C {}

//声明一个抽象方法
abstract class C1 {
  def say()
}

//特质1
trait T1 {
  println("T1")

  def insert(i: Int)
}

//特质2
trait T2 extends T1 {
  println("T2")

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

//特质3
trait T3 extends T2 {
  println("T3")

  //实际上是调用父特质的方法T2 ：super.insert(i)
  override def insert(i: Int): Unit = super.insert(i)
}

//特质4
trait T4 extends T2 {
  println("T4")

  //实际上是调用左边的特质的方法T3 ：super.insert(i)
  override def insert(i: Int): Unit = super.insert(i)
}