特质

1、java中多实现的表达是通过接口，scala中用特质来代替接口。也就是说，多个类具有相同的特质（特征）时，就可以将这个特质独立出来，采用关键字trait声明。

2、scala中的trait中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特征。这种感觉类似于java中的抽象类。

3、scala引入trait特征，第一可以代替java的接口，第二个也是对单继承机制的一种补充。

 

 

特质基本语法：

trait 特质名 { trait主体 }

1、采用extends关键字，如果有多个特质或存在父类，那么需要采用with关键字连接。

2、没有父类：class 类名 extends 特质1 with 特质2 with 特质3 .....

      有父类：class 类名 extends 父类 with 特质1 with 特质2 with 特质3 .....

3、说明：

   （1）类和特质的关系：使用继承的关系。

   （2）当一个类要去继承特质时，第一个连接词是extends，后面是with。

   （3）如果一个类在同事继承特质和父类时，应当把父类写在extends后。

例子：

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

    val student8: Student8 = new Student8()
    student8.sayHei()
    student8.study()
    student8.dating()
    student8.play()
  }
}
//定义一个父类
class Person8 {
  val name: String = "person"
  var age: Int = 22
  def sayHei(): Unit = {
    println("hello" + name)
  }
}
//定义一个特质
trait Young {
  //声明抽象和非抽象属性
  var age: Int
  val name: String = "young"

  //声明抽象和非抽象的方法
  def play(): Unit = {
    println("young people is playing")
  }
  def dating(): Unit
}
class Student8 extends Person8 with Young {
  //重写冲突的属性，不然会报错
  override val name: String = "student"

  //实现抽象方法
  def dating(): Unit = println(s"student $name is dating")
  //
  def study(): Unit = println(s"student $name is studing")

  //重写父类方法
  override def sayHei(): Unit = {
    super.sayHei()
    println(s"hei from : student " +name)
  }
}

 

 

 

动态混入：

object Test9_TraitMixin {
  def main(args: Array[String]): Unit = {
    val student = new Student9()
    student.study()
    student.increase()

    student.play()
    student.increase()

    student.dating()
    student.increase()
    println("-------------------------------")

    //动态混入,可以在new的时候使用
    val studentWithTalent = new Student9 with Talent {
      override def dance(): Unit = println("student is good at dance")
      override def sing(): Unit = println("student is good at sing")
    }
    studentWithTalent.dance()

    studentWithTalent.sayHei()
    studentWithTalent.play()
  }
}
trait Knowledge {
  var amount:Int = 0
  def increase():Unit
}

trait Talent {
  def sing(): Unit
  def dance(): Unit
}

class Student9 extends Person8 with Young with Knowledge {
  //重写冲突的属性，不然会报错
  override val name: String = "student"

  //实现抽象方法
  def dating(): Unit = println(s"student $name is dating")
  //
  def study(): Unit = println(s"student $name is studing")

  //重写父类方法
  override def sayHei(): Unit = {
    super.sayHei()
    println(s"hei from : student " +name)
  }

  //实现特质中的抽象方法
  override def increase(): Unit = {
    amount += 1
    println(s"student $name knowledge increased: $amount")
  }
}

 

 

特征叠加：

1、如果特征中的方法重复了，调用时会使用最后一个特征（可以说是覆盖）。

2、如果确定的使用其中一个特征可以使用super[特征或者类].方法。   

   

自身类型

object Test10_TraitSelfType {
  def main(args: Array[String]): Unit = {
    val user = new RegisterUser("wl", "123456")
    user.insert()
  }
}
//定义一个用户类
class User(val name:String, val password:String)

trait UserDao {
  //UserDao的类型定义成了User, 可以认为UserDao里面有了一个User
  //UserDao要使用User里的一些属性，又不想有继承的关系,相当于实现了依赖注入的功能
  _: User =>
  //向数据库插入数据
  def insert(): Unit = {
    //只能使用this. 不能直接使用参数名
    println(s"insert into db: ${this.name}")
  }
}

//定义注册用户类
class RegisterUser(name:String, password:String) extends User(name, password) with UserDao