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)
}
}