Scala:Trait

将trait作为接口使用

类可以使用extends关键字继承trait，注意，这里不是implement，而是extends，在scala中没有implement的概念，无论继承类还是trait，统一都是extends。
类继承trait后，必须实现其中的抽象方法，实现时不需要使用override关键字

trait SayHello {
   def sayHello(name:String)
}

trait MakeFriendsTrait {
   def makeFriends(p:Person)
}

class Person(val name:String) extends SayHello with MakeFriendsTrait {
  def sayHello(otherName:String) = println(" Hello," + otherName+ " ,I'm " + name)
  def makeFriends(p:Person) = println("Hello, my name is " + name + ",your name is " + p.name )
}

scala不支持对类进行多继承，但是支持多重继承trait，使用with关键字即可

在Trait中定义具体方法

Scala中的Triat可以不是只定义抽象方法，还可以定义具体方法，此时trait的功能混入了类

trait Logger {
   def log(message:String) = println(message)
}

class Person(val name:String) extends Logger{
  def makeFriends(p:Person){
    println(" Hi,I'm " + name + "l'm glad to make friends with you," + p.name)
    log("makeFriends methdo is invoked with parameter Person[name=" + p.name + "]")
   }
}

在Trait中定义具体字段

Scala中的Triat可以定义具体field，此时继承trait的类就自动获得了trait中定义的field

trait Person{
 val eyeNum:Int = 2
}

class Student(val name:String) extends Person {
  def sayHello =println("Hi, I'm " + name + ", I have " + eyeNum + " eyes.")
}

这种获取field的方式与继承class是不同的：如果是继承class获取的field，实际是定义在父类中的；而继承trait获取的field，就直接被添加到了类中

在Trait中定义抽象字段

Scala中的Triat可以定义抽象field，而trait中的具体方法则可以基于抽象field来编写，继承trait的类，则必须覆盖抽象field，提供具体的值

trait SayHello{
  val msg:String
  def sayHello(name:String) = println(msg + "," + name)
}

class Person(val name:String) extends SayHello{
  val msg:String = "Hello"
  def makeFriends(p:Person){
     sayHello(p.name)
     println("I'm " + name + ", I want to make friends with you.")
  }
}

为实例混入trait

有时我们可以在创建类的对象时，指定该对象混入某个trait，这样，就只有这个对象混入该trait的方法，而类的其他对象则没有。

trait Logged {
  def log(msg:String){}
}

trait MyLogger extends Logged {
   override def log(msg:String) {
     println("log:" + msg)
   }
}

class Person(val name:String) extends Logged {
   def sayHello {
     println("HI, I'm " + name)
     log("sayHello is invoked")
   }
}

val p1 = new Person("leo")
p1.sayHello

val p2 = new Person("jack") with MyLogger
p2.sayHello

trait调用链（责任链模式）

Scala中支持让类继承多个trait后，依次调用多个trait中的同一个方法，只要让多个trait的同一个方法中，在最后都执行super.方法即可

trait Hander {
    def hander(data:String){}
}

trait DataValidHandler extends Hander {
   override def hander(data:String){
           println("check data: " + data)
           super.hander(data)
   }
}

trait SignatureValidHandler extends Hander {
    override def hander(data:String){
           println("check signature: " + data)
           super.hander(data)
     }
}
class Person(val name:String) extends SignatureValidHandler with DataValidHandler {
      def sayHello = {
           println(" Hello," + name)
           hander(name)
      }
 }

类中调用多个trait中都有的这个方法时，首先会从最右边的trait的方法开始执行，然后依次往左执行，形成一个调用链条

在trait中覆盖抽象方法

在trait中，是可以覆盖父trait的抽象方法的, 但如果使用了super.方法的代码，则无法通过编译。因为super.方法就会去掉用父trait的抽象方法，此时子trait的该方法还是会被认为是抽象的。

trait Logger{
   def log(msg:String)
}

trait MyLogger extends Logger{
  abstract override def log(msg:String){
       super.log(msg)
   }
}

混合使用trait的具体方法和抽象方法（模板设计模式）

在trait中，可以混合使用具体方法和抽象方法，可以让具体方法依赖于抽象方法，而抽象方法则放到继承trait的类中去实现。

trait Valid {
  def getName:String
  def valid:Boolean = {
     getName == "A"
   }
}

class Person(val name:String) extends Valid{
      println(valid)
      def getName = name
}

trait的构造机制

在Scala中，trait也是有构造代码的，也就是trait中的，不包含在任何方法中的代码

• 调用超类的构造器
• 特征构造器在超类构造器之后、类构造器之前执行
• 特征由左到右被构造
• 每个特征当中，父特征先被构造
• 如果多个特征共有一个父特征，父特征不会被重复构造
• 所有特征被构造完毕，子类被构造
  

trait field的初始化

在Scala中，trait是没有接收参数的构造函数的，这是trait与class的唯一区别，但是如果需求就是要trait能够对field进行初始化，该怎么办呢？只能使用Scala中非常特殊的一种高级特性——提前定义

trait SayHello {
	val msg:String
	println(msg.toString)
}

class Person extends { val msg:String = "init" } with SayHello {
}

class Person

val p = new {
  val msg: String = "init"
} with Person with SayHello

另外一种方式就是使用lazy value

trait SayHello {
  lazy val msg: String = null
  println(msg.toString)
}

class Person extends SayHello {
  override lazy val msg: String = "init"
}

trait继承class

在Scala中，trait也可以继承自class，此时这个class就会成为所有继承该trait的类的父类

class MyUtil {
   def printMessage(msg:String) = println(msg)
}


  trait Logger extends MyUtil {
     def log(msg:String) =printMessage("log:" + msg)
}

class Person(val name:String) extends Logger{
   def sayHello{
      log("hi,I'm" + name)
      printMessage("hi , i'm " + name)
   }
}