Scala之Trait的使用

Trait让我们想到了Java的interface，但是却和interface有很大的不同

Trait可以比喻为一个拥有部分实现的接口，其提供了一个介于单一继承和多重继承的中间地带，因为我们可以在其他类里混入它们。

1、trait里面定义和初始化的val和var会混入trait的类的内部得到实现

2、定义过未初始化的val和var则认为是抽象的，需要由混入这些trait的类实现，此外 ，它们的构造器不能有任何参数

3、混入trait的数量是任意的，用with关键字可以混入更多的trait

4、一个类被混入trait之后，通过它的实例可以调用到trait的方法，也可以把它的引用当做trait的引用

5、trait会编译成Java接口，还有对应的实现类，里面包含了trait实现的方法

6、可以在实例一级对trait进行选择性混入，就可以把特定的类当做trait

7、在trait里，通过super调用的方法会经历 一个延迟绑定的过程，这个调用并不是对基类的调用，而是对其左边混入的trait的调用--如果这个trait已经是混入的最左trait，那么这个调用就会解析成混入这个trait的类的方法。

8、trait中字段可以是具体的，可以是抽象的；如果给了初始值，就是具体的，则使用该trait的类会获得一个字段与之对应，其不是被继承过来的，只是简单的被加入到子类中；原因是在JVM中一个类只能扩展一个超类

package com.scala.oop

/**
 * @author tengfei
 * 多重继承 trait 和 interface的不同之处在于？？？可以有方法的实现 可以在模块中混入多个trait 实现不同的方面
 */

class Human{
  println("Human")
}

trait Teacher1 extends Human{
  println("Teacher")
  
  def teach
}

trait PianoPlayer extends Human{
  println("PianPlayer")
  
  def playPiano = {println("I am playing piano")}
}

class PianoTeacher extends Human with Teacher1 with PianoPlayer{
  override def teach = println("I am teaching a student")
}

// AOP
trait Action{
  def doAction
}

trait TBeforeAfter extends Action{
  abstract override def doAction{
    println("Initialization ")
    super.doAction
    println("Destroyed")
  }
}

class Work extends Action{
  override def doAction = println("Working....")
}

object traitOps extends App{
  
  val pt = new PianoTeacher
  pt.teach
  
  val pt2 = new Human with Teacher1 with PianoPlayer{
    override def teach = println("I am teaching a student")
  }
  pt2.playPiano
  pt2.teach
  
  val work = new Work with TBeforeAfter
  work.doAction
  
}

package com.scala.oop

/**
 * @author tengfei
 */


abstract class Check{
  def check():String = "Checked Application Details..."
}

trait CreditCheck extends Check{
  override def check():String = "Checked Credit..." + super.check()
}

trait EmploymentCheck extends Check{
  override def check():String = "Checked Employment..." + super.check()
}

trait CriminalRecordCheck extends Check{
  override def check():String = "Checked CriminalRecord..." + super.check()
}

// 把上面的三个trait混入继承自Check的类
// 继承这个类给予了我们这样的权利：首先这些trait只能混入继承自Check的类；其次，这些trait里可以使用Check的方法


abstract class Writer{
  def writeMsg(message:String) 
}

// trait 内方法必须为abstract
trait UpperCaseWriter extends Writer{
  abstract override def writeMsg(message:String) = super.writeMsg(message.toUpperCase)
}

trait ProfanityFilteredCaseWriter extends Writer{
  abstract override def writeMsg(message:String) = super.writeMsg(message.replace("spa","s-----"))
}

class StringWriteDelegate extends Writer{
  val writer = new java.io.StringWriter
  
  def writeMsg(message:String) = writer.write(message)
  override def toString():String = writer.toString
}


object traitOps1 {
  def main(args:Array[String]):Unit={
    // 1
    val apartAppl = new Check with CreditCheck with CriminalRecordCheck
    println(apartAppl check)
    
    // 2
    val myWPFirst = new StringWriteDelegate with UpperCaseWriter with ProfanityFilteredCaseWriter
    myWPFirst.writeMsg("hello spark")
    
    val myWPSecond = new StringWriteDelegate with ProfanityFilteredCaseWriter with UpperCaseWriter
    myWPSecond.writeMsg("hello spark")   
    
    println(myWPFirst)
    println(myWPSecond)    
  }
}