1、特质

trait A{
  val num: Int
  def fun(): Unit = {
    println("A")
  }
}

trait B{
  val num: Int = 10
  def fun(): Unit = {
    println("B")
  }
}

class Student14 extends Person13 with A with B{

  //重写方法 fun
  override def fun(): Unit = {
    super.fun() //最后继承的特质是B 所以fun方法会调用B的fun方法
  }

}

object Test14_TraitOverlying {
  def main(args: Array[String]): Unit = {
    val stu = new Student14
    stu.fun() //输出 B
    println(stu.num)    //10
  }
}

特质叠加的顺序

        特质A和B中都含有变量num，但是特质A并没有初始化num的值，而特质B初始化了num的值。正因为最后继承了特质B，而特质B中实现了num变量的赋值，所以我们在子类中不需要实现或者重写num的值，可以直接访问num的值，这时候访问到的也就是特质B中初始化的值。

        如果A也初始化了num的值，则B无法叠加。

        如果A初始化了num的值，B没有，尽管最后继承的是特质B，但B仍然无法覆盖num，所以访问到的是A定义的num的值。

trait horse{
  val name: String = "马"
}
trait donkey{
  val name: String 
}

class Animal{

}

//骡子
class Mule extends Animal with horse with donkey {

}

object Test {

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

    val mule = new Mule
    println(mule.name)    //马

  }

}

trait horse{
  val name: String
}
trait donkey{
  val name: String = "驴"
}

class Animal{
}

//骡子
class Mule extends Animal with horse with donkey {
 
}

object Test {

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

    val mule = new Mule
    println(mule.name)    //驴

  }

}

• 第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala 采用了特质叠加的策略

object Test {

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

    val mule = new Mule
    println(mule.describe())    //骡子是 驴-马-爬行动物


  }

}

trait horse extends crawler {
  val t1: String = "马-"

  override def describe(): String = t1 + super.describe()
}
trait donkey extends crawler {
  val t2: String = "驴-"

  override def describe(): String = t2 + super.describe()
}

//爬行动物特征
trait crawler {
  def describe(): String = {
    "爬行动物"
  }
}


//骡子
class Mule extends horse with donkey {
  override def describe(): String = "骡子是 " + super.describe()
}

特质叠加顺序：骡子 -> 驴 -> 马 -> 爬行动物 

指定父类的方法

        直接 super[父类].方法名，这样就不会去使用叠加后的方法，而是直接使用我们指定的子类的某个父类的方法，不用担心被叠加的问题

class Mule extends horse with donkey {
  override def describe(): String = "骡子是 " + super[horse].describe()
}
object Test {
  def main(args: Array[String]): Unit = {

    val mule = new Mule
    println(mule.describe())    //骡子是 马-爬行动物

  }
}

super关键字

        在Scala中，super关键字只能用于调用父类的方法，不能用于访问或调用父类的属性。这是因为在Scala中，属性访问器(getter和setter)实际上是方法的一种特殊形式。如果需要在子类中访问父类的属性，你可以在父类中定义一个公共的方法（getter方法）来返回属性的值。然后在子类中通过调用该方法来获取父类的属性值。

1.4、自身类型

自身类型实现了 依赖注入 的功能。

案例-用户注册

package chapter06

object Test16_SelfType {

  def main(args: Array[String]): Unit = {
    val user = new RegisterUser("tom","123456")
    user.register()
  }

}

class User(val name: String,val password: String)

trait UserDao{
  //把自身类型定义为User 相当于我们已经有一个User实例对象 直接在这操作
  _: User =>
  def register(): Unit = {
    val res =
       s"""
        |注册成功!
        |用户名: ${this.name}
        |密码:   ${this.password}
        |""".stripMargin

    println(res)
  }
}

class RegisterUser(name: String,password: String) extends User(name, password) with UserDao

注册成功!
用户名: tom
密码:   123456

1.5、扩展

类型的检查与转换

1. obj.isInstanceOf[T]：判断 obj 是不是 T 类型。
2. obj.asInstanceOf[T]：将 obj 强转成 T 类型。
3. classOf： 获取对象的类名。

枚举和应用类

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

    println(WorkDay.MONDAY) //Monday
    println(WorkDay.TUESDAY) //Tuesday

  }
}

//定义枚举类对象
object WorkDay extends Enumeration{
  val MONDAY = Value(1,"Monday")
  val TUESDAY = Value(2,"Tuesday")
}

//定义应用类对象 不需要main方法 直接就可以运行
object TestApp extends App{
  println("app start")
}

Type 

 type Str = String
  val word: Str = "hello"
  print(word)