版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
将trait作为接口使用
Scala中的Triat是一种特殊的概念。首先我们可以将Trait作为接口来使用，此时的Triat就与Java中的接口非常类似。在triat中可以定义抽象方法，就与抽象类中的抽象方法一样，只要不给出方法的具体实现即可。类可以使用extends关键字继承trait，注意，这里不是implement，而是extends，在scala中没有implement的概念，无论继承类还是trait，统一都是extends。类继承trait后，必须实现其中的抽象方法，实现时不需要使用override关键字。scala不支持对类进行多继承，但是支持多重继承trait，使用with关键字即可。
trait HelloTrait_13_1 {
def sayHello(name:String)
}
trait MakeFriends_13_1 {
def makeFriends(p:Persion_13_1_3)
}
class Persion_13_1_3(val name:String) extends HelloTrait_13_1 with MakeFriends_13_1 {
override def sayHello(name: String): Unit = {
println("Hello " + name)
}
override def makeFriends(p: Persion_13_1_3): Unit = {
println("Hello, my name is " + name + ", your name is " + p.name)
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//-----------13---------1--------将trait作为接口使用
val p = new HelloTrait_13_1 {
override def sayHello(name: String): Unit = {}
}
val pw = new Persion_13_1_3("wahaha")
val ps = new Persion_13_1_3("siisjiang")
pw.sayHello("liu") //Hello liu
pw.makeFriends(ps) //Hello, my name is wahaha, your name is siisjiang
}
}
在Trait中定义具体方法
Scala中的Triat可以不是只定义抽象方法，还可以定义具体方法，此时trait更像是包含了通用工具方法的东西 // 有一个专有的名词来形容这种情况，就是说trait的功能混入了类。举例来说，trait中可以包含一些很多类都通用的功能方法，比如打印日志等等，spark中就使用了trait来定义了通用的日志打印方法。
trait Longger_13_2_1 {
def long(message:String)=println(message)
}
class Persion_13_2_2(val name :String) extends Longger_13_2_1 {
def makeFriends(p:Persion_13_2_2): Unit ={
println("Hi, I'm " + name + ", I'm glad to make friends with you, " + p.name)
long("diao yong" + p.name)
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------2-----在Trait中定义具体方法
val p = new Persion_13_2_2("wahaha")
val p1 = new Persion_13_2_2("hahahya")
p.makeFriends(p1)
//Hi, I'm wahaha, I'm glad to make friends with you, hahahya
//diao yonghahahya
}
}
在trait中定义具体字段
Scala中的Triat可以定义具体field，此时继承trait的类就自动获得了trait中定义的field。但是这种获取field的方式与继承class是不同的：如果是继承class获取的field，实际是定义在父类中的；而继承trait获取的field，就直接被添加到了类中。
trait Persion_13_3_1 {
val eyeNum:Int = 2
}
class Student_13_3_2(val name: String) extends Persion_13_3_1 {
def sayHello = println("Hi, I'm " + name + ", I have " + eyeNum + " eyes.")
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------3-----在trait中定义具体字段
val a = new Student_13_3_2("tom")
a.sayHello //Hi, I'm tom, I have 2 eyes.
}
}
在Trait中定义抽象字段
Scala中的Triat可以定义抽象field，而trait中的具体方法则可以基于抽象field来编写。 但是继承trait的类，则必须覆盖抽象field，提供具体的值。
trait sayHello_13_4_1 {
val msg :String
def sayHello(name:String) = println(msg + ":" + name)
}
class Persion_13_4_2(val name : String) extends sayHello_13_4_1 {
val msg : String = "hello "
def makeFriends(p: Persion_13_4_2): Unit ={
sayHello(p.name)
println("I'm " + name + ", I want to make friends with you!")
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------4----- 在Trait中定义抽象字段
val a = new Persion_13_4_2("haha00")
a.sayHello(a.name) //hello :haha00
val a2 = new Persion_13_4_2("liu")
a.makeFriends(a2)
//hello :liu
//I'm haha00, I want to make friends with you!
}
}
为实列混入trait
有时我们可以在创建类的对象时，指定该对象混入某个trait，这样，就只有这个对象混入该trait的方法，而类的其他对象则没有。
trait Logged_13_6_1 {
//这不是抽象方法，去掉{}才是抽象方法
def log(mgs: String){}
}
trait myLogger_13_6_2 extends Logged_13_6_1 {
override def log(mgs: String): Unit = {
println("log : " + mgs)
}
}
class Persion_13_6_3(val name:String) extends Logged_13_6_1 {
def sayHello: Unit ={
println("hi i am " + name)
log("this is sayHello ")
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------4----- 为实列混入trait
val p1 = new Persion_13_6_3("tom")
p1.sayHello //hi i am tom
val p2 = new Persion_13_6_3("joker") with myLogger_13_6_2
p2.sayHello
//hi i am joker
//log : this is sayHello
}
}
trait调用链
Scala中支持让类继承多个trait后，依次调用多个trait中的同一个方法，只要在多个trait的同一个方法最后都执行super.方法即可。类中调用多个trait中都有的这个方法时，首先会从最右边的trait的方法开始执行，然后依次往左执行，形成一个调用链条。这种特性非常强大，其实就相当于设计模式中的责任链模式的一种具体实现依赖。
trait Hangler_13_7_1 {
//这不是抽象方法，去掉{}才是抽象方法
def handler(data:String){}
}
trait DataValidHandler_13_7_2 extends Hangler_13_7_1 {
override def handler(data: String): Unit = {
println("chenk data :" + data)
super.handler(data)
}
}
trait SignatureValidHandler_13_7_3 extends Hangler_13_7_1 {
override def handler(data: String): Unit = {
println("chenk signature:" + data)
super.handler(data)
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------7----- tarit调用链
val a = new Person_13_7_4("wahaha")
a.sayHello
//Hello wahaha
//chenk signature:wahaha
//chenk data :wahaha
}
}
在trait中覆盖抽象方法
在trait中，是可以覆盖父trait的抽象方法的。但是覆盖时，如果使用了super.方法的代码，则无法通过编译。因为super.方法就会去掉用父trait的抽象方法，此时子trait的该方法还是会被认为是抽象的。此时如果要通过编译，就得给子trait的方法加上abstract override修饰
trait Logger_13_8_1 {
def log(msg:String)
}
trait Mylogger_13_8_2 extends Logger_13_8_1 {
abstract override def log(msg: String): Unit = {
super.log(msg)
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------8--在trait中覆盖抽象方法
// 下边的代码是不能运行的,由于是运行MyLogger_13_7_2的log方法，再调用Logger_13_7_1的log本身就是抽象方法
// 没有具体的实现，所以在这里没有具体的输出，只是编译过程通过。
val p = new Mylogger_13_8_2 {
override def log(msg: String): Unit = {
println(msg + "fei jin a" )
}
}
p.log("hen")
}
}
混合使用trait的具体方法和抽象方法
在trait中，可以混合使用具体方法和抽象方法。可以让具体方法依赖于抽象方法，而抽象方法则放到继承trait的类中去实现。 这种trait其实就是设计模式中的模板设计模式的体现
trait Vaild_13_9_1 {
def getName:String
def vaild:Boolean = {
getName == "leo"
}
}
class Persion_13_9_2(val name :String) extends Vaild_13_9_1 {
println(vaild)
override def getName: String = name
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------9---- 混合使用trait的具体方法和抽象方法
// val a = new Persion_13_9_2("leo")
// a.getName //
val w = new Persion_13_9_2("tom")
w.getName //false
}
}
trait的类的构造机制
继承了trait的类的构造机制如下：
1、父类的构造函数执行；
2、trait的构造代码执行，多个trait从左到右依次执行；
3、构造trait时会先构造父trait，如果多个trait继承同一个父trait，则父trait只会构造一次；
4、所有trait构造完毕之后，子类的构造函数执行。
class Persion_13_10_1 {
println("Persion constructor")
}
trait Logger_13_10_2 {
println("Logger's constructor!")
}
trait MyLogger_13_10_3 extends Logger_13_10_2 {
println("MyLogger's constructor!")
}
trait TimeLogger_13_10_4 extends Logger_13_10_2 {
println("TimeLogger's constructor!")
}
class Student_13_10_5 extends Logger_13_10_2 with MyLogger_13_10_3 with TimeLogger_13_10_4 {
println("Student's constructor!")
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------10---- trait的构造机制
// val a1 = new Student_13_10_5
// println(a1)
//Logger's constructor!
//MyLogger's constructor!
//TimeLogger's constructor!
//Student's constructor!
//com.scala6.trail.Student_13_11_5@1c7db30
}
}
trait field的初始化
在Scala中，trait是没有接收参数的构造函数的，这是trait与class的唯一区别，但是如果需求就是要trait能够对field进行初始化，只能使用Scala中非常特殊的一种高级特性——提前定义。
trait SayHello_13_10_1 {
val msg: String
println(msg.toString)
}
class Person_13_10_1
val p = new {
val msg: String = "init"
} with Person_13_10_1 with SayHello_13_10_1
class Person_13_10_2 extends {
val msg: String = "init"
} with SayHello_13_10_1 {}
// 另外一种方式就是使用lazy value
trait SayHello_13_10_2 {
lazy val msg: String = null
println(msg.toString)
}
class Person_13_10_4 extends SayHelloSayHello_13_10_2 {
override lazy val msg: String = "init"
}
trait继承class
在Scala中，trait也可以继承自class，此时这个class就会成为所有继承该trait的类的父类。
class MyUitl_13_12_1 {
def printMessage(msg: String) = println(msg)
}
trait Logger_13_12_2 extends MyUitl_13_12_1 {
def log(msg :String) = printMessage("log :" + msg)
}
class Persion_13_12_3(val name :String) extends Logger_13_12_2 {
def sayHello: Unit ={
log("hi name: " + name)
printMessage("Hi I'm " + name)
}
}
object Text_13 {
def main(args: Array[String]): Unit = {
//------13--------12---- trait继承class
val a = new Persion_13_12_3("ton")
a.sayHello
//log :hi name: ton
//Hi I'm ton
}
}