面向?qū)ο缶幊讨?/h1>
定義一個(gè)簡(jiǎn)單的類
// 定義類，包含field以及方法
class HelloWorld {
private var name = "leo"
def sayHello() { print("Hello, " + name) }
def getName = name
}
// 創(chuàng)建類的對(duì)象，并調(diào)用其方法
val helloWorld = new HelloWorld
helloWorld.sayHello()
print(helloWorld.getName) // 也可以不加括號(hào)，如果定義方法時(shí)不帶括號(hào)，則調(diào)用方法時(shí)也不能帶括號(hào)
getter與setter
// 定義不帶private的var field，此時(shí)scala生成的面向JVM的類時(shí)，會(huì)定義為private的name字段，并提供public的getter和setter方法
// 而如果使用private修飾field，則生成的getter和setter也是private的
// 如果定義val field，則只會(huì)生成getter方法
// 如果不希望生成setter和getter方法，則將field聲明為private[this]
class Student {
var name = "leo"
}
// 調(diào)用getter和setter方法，分別叫做name和name_ =
val leo = new Student
print(leo.name)
leo.name = "leo1"
自定義getter與setter
// 如果只是希望擁有簡(jiǎn)單的getter和setter方法，那么就按照scala提供的語(yǔ)法規(guī)則，根據(jù)需求為field選擇合適的修飾符就好：var、val、private、private[this]
// 但是如果希望能夠自己對(duì)getter與setter進(jìn)行控制，則可以自定義getter與setter方法
// 自定義setter方法的時(shí)候一定要注意scala的語(yǔ)法限制，簽名、=、參數(shù)間不能有空格
class Student {
private var myName = "leo"
def name = "your name is " + myName
def name_=(newValue: String) {
print("you cannot edit your name!!!")
}
}
val leo = new Student
print(leo.name)
leo.name = "leo1"
僅暴露field的getter方法
// 如果你不希望field有setter方法，則可以定義為val，但是此時(shí)就再也不能更改field的值了
// 但是如果希望能夠僅僅暴露出一個(gè)getter方法，并且還能通過(guò)某些方法更改field的值，那么需要綜合使用private以及自定義getter方法
// 此時(shí)，由于field是private的，所以setter和getter都是private，對(duì)外界沒(méi)有暴露；自己可以實(shí)現(xiàn)修改field值的方法；自己可以覆蓋getter方法
class Student {
private var myName = "leo"
def updateName(newName: String) {
if(newName == "leo1") myName = newName
else print("not accept this new name!!!")
}
def name = "your name is " + myName
}
private[this]的使用
// 如果將field使用private來(lái)修飾，那么代表這個(gè)field是類私有的，在類的方法中，可以直接訪問(wèn)類的其他對(duì)象的private field
// 這種情況下，如果不希望field被其他對(duì)象訪問(wèn)到，那么可以使用private[this]，意味著對(duì)象私有的field，只有本對(duì)象內(nèi)可以訪問(wèn)到
class Student {
private var myAge = 0
def age_=(newValue: Int) {
if (newValue > 0) myAge = newValue
else print("illegal age!")
}
def age = myAge
def older(s: Student) = {
myAge > s.myAge
}
}
Java風(fēng)格的getter和setter方法
// Scala的getter和setter方法的命名與java是不同的，是field和field_=的方式
// 如果要讓scala自動(dòng)生成java風(fēng)格的getter和setter方法，只要給field添加@BeanProperty注解即可
// 此時(shí)會(huì)生成4個(gè)方法，name: String、name_=(newValue: String): Unit、getName(): String、setName(newValue: String): Unit
import scala.reflect.BeanProperty
class Student {
@BeanProperty var name: String = _
}
class Student(@BeanProperty var name: String)
val s = new Student
s.setName("leo")
s.getName()
輔助constructor
// Scala中，可以給類定義多個(gè)輔助constructor，類似于java中的構(gòu)造函數(shù)重載
// 輔助constructor之間可以互相調(diào)用，而且必須第一行調(diào)用主constructor
class Student {
private var name = ""
private var age = 0
def this(name: String) {
this()
this.name = name
}
def this(name: String, age: Int) {
this(name)
this.age = age
}
}
主constructor
// Scala中，主constructor是與類名放在一起的，與java不同
// 而且類中，沒(méi)有定義在任何方法或者是代碼塊之中的代碼，就是主constructor的代碼，這點(diǎn)感覺(jué)沒(méi)有java那么清晰
class Student(val name: String, val age: Int) {
println("your name is " + name + ", your age is " + age)
}
// 主constructor中還可以通過(guò)使用默認(rèn)參數(shù)，來(lái)給參數(shù)默認(rèn)的值
class Student(val name: String = "leo", val age: Int = 30) {
println("your name is " + name + ", your age is " + age)
}
// 如果主constrcutor傳入的參數(shù)什么修飾都沒(méi)有，比如name: String，那么如果類內(nèi)部的方法使用到了，則會(huì)聲明為private[this] name；否則沒(méi)有該field，就只能被constructor代碼使用而已
內(nèi)部類
// Scala中，同樣可以在類中定義內(nèi)部類；但是與java不同的是，每個(gè)外部類的對(duì)象的內(nèi)部類，都是不同的類
import scala.collection.mutable.ArrayBuffer
class Class {
class Student(val name: String) {}
val students = new ArrayBuffer[Student]
def getStudent(name: String) = {
new Student(name)
}
}
val c1 = new Class
val s1 = c1.getStudent("leo")
c1.students += s1
val c2 = new Class
val s2 = c2.getStudent("leo")
c1.students += s2
面向?qū)ο缶幊讨畬?duì)象
object
// object，相當(dāng)于class的單個(gè)實(shí)例，通常在里面放一些靜態(tài)的field或者method
// 第一次調(diào)用object的方法時(shí)，就會(huì)執(zhí)行object的constructor，也就是object內(nèi)部不在method中的代碼；但是object不能定義接受參數(shù)的constructor
// 注意，object的constructor只會(huì)在其第一次被調(diào)用時(shí)執(zhí)行一次，以后再次調(diào)用就不會(huì)再次執(zhí)行constructor了
// object通常用于作為單例模式的實(shí)現(xiàn)，或者放class的靜態(tài)成員，比如工具方法
object Person {
private var eyeNum = 2
println("this Person object!")
def getEyeNum = eyeNum
}
伴生對(duì)象
// 如果有一個(gè)class，還有一個(gè)與class同名的object，那么就稱這個(gè)object是class的伴生對(duì)象，class是object的伴生類
// 伴生類和伴生對(duì)象必須存放在一個(gè).scala文件之中
// 伴生類和伴生對(duì)象，最大的特點(diǎn)就在于，互相可以訪問(wèn)private field
object Person {
private val eyeNum = 2
def getEyeNum = eyeNum
}
class Person(val name: String, val age: Int) {
def sayHello = println("Hi, " + name + ", I guess you are " + age + " years old!" + ", and usually you must have " + Person.eyeNum + " eyes.")
}
讓object繼承抽象類
// object的功能其實(shí)和class類似，除了不能定義接受參數(shù)的constructor之外
// object也可以繼承抽象類，并覆蓋抽象類中的方法
abstract class Hello(var message: String) {
def sayHello(name: String): Unit
}
object HelloImpl extends Hello("hello") {
override def sayHello(name: String) = {
println(message + ", " + name)
}
}
apply方法
// object中非常重要的一個(gè)特殊方法，就是apply方法
// 通常在伴生對(duì)象中實(shí)現(xiàn)apply方法，并在其中實(shí)現(xiàn)構(gòu)造伴生類的對(duì)象的功能
// 而創(chuàng)建伴生類的對(duì)象時(shí)，通常不會(huì)使用new Class的方式，而是使用Class()的方式，隱式地調(diào)用伴生對(duì)象得apply方法，這樣會(huì)讓對(duì)象創(chuàng)建更加簡(jiǎn)潔
// 比如，Array類的伴生對(duì)象的apply方法就實(shí)現(xiàn)了接收可變數(shù)量的參數(shù)，并創(chuàng)建一個(gè)Array對(duì)象的功能
val a = Array(1, 2, 3, 4, 5)
// 比如，定義自己的伴生類和伴生對(duì)象
class Person(val name: String)
object Person {
def apply(name: String) = new Person(name)
}
main方法
// 就如同java中，如果要運(yùn)行一個(gè)程序，必須編寫一個(gè)包含main方法類一樣；在scala中，如果要運(yùn)行一個(gè)應(yīng)用程序，那么必須有一個(gè)main方法，作為入口
// scala中的main方法定義為def main(args: Array[String])，而且必須定義在object中
object HelloWorld {
def main(args: Array[String]) {
println("Hello World!!!")
}
}
// 除了自己實(shí)現(xiàn)main方法之外，還可以繼承App Trait，然后將需要在main方法中運(yùn)行的代碼，直接作為object的constructor代碼；而且用args可以接受傳入的參數(shù)
object HelloWorld extends App {
if (args.length > 0) println("hello, " + args(0))
else println("Hello World!!!")
}
// 如果要運(yùn)行上述代碼，需要將其放入.scala文件，然后先使用scalac編譯，再用scala執(zhí)行
scalac HelloWorld.scala
scala -Dscala.time HelloWorld
// App Trait的工作原理為：App Trait繼承自DelayedInit Trait，scalac命令進(jìn)行編譯時(shí)，會(huì)把繼承App Trait的object的constructor代碼都放到DelayedInit Trait的delayedInit方法中執(zhí)行
用object來(lái)實(shí)現(xiàn)枚舉功能
// Scala沒(méi)有直接提供類似于Java中的Enum這樣的枚舉特性，如果要實(shí)現(xiàn)枚舉，則需要用object繼承Enumeration類，并且調(diào)用Value方法來(lái)初始化枚舉值
object Season extends Enumeration {
val SPRING, SUMMER, AUTUMN, WINTER = Value
}
// 還可以通過(guò)Value傳入枚舉值的id和name，通過(guò)id和toString可以獲取; 還可以通過(guò)id和name來(lái)查找枚舉值
object Season extends Enumeration {
val SPRING = Value(0, "spring")
val SUMMER = Value(1, "summer")
val AUTUMN = Value(2, "autumn")
val WINTER = Value(3, "winter")
}
Season(0)
Season.withName("spring")
// 使用枚舉object.values可以遍歷枚舉值
for (ele <- Season.values) println(ele)
面向?qū)ο缶幊讨^承
extends
// Scala中，讓子類繼承父類，與Java一樣，也是使用extends關(guān)鍵字
// 繼承就代表，子類可以從父類繼承父類的field和method；然后子類可以在自己內(nèi)部放入父類所沒(méi)有，子類特有的field和method；使用繼承可以有效復(fù)用代碼
// 子類可以覆蓋父類的field和method；但是如果父類用final修飾，field和method用final修飾，則該類是無(wú)法被繼承的，field和method是無(wú)法被覆蓋的
class Person {
private var name = "leo"
def getName = name
}
class Student extends Person {
private var score = "A"
def getScore = score
}
override和super
// Scala中，如果子類要覆蓋一個(gè)父類中的非抽象方法，則必須使用override關(guān)鍵字
// override關(guān)鍵字可以幫助我們盡早地發(fā)現(xiàn)代碼里的錯(cuò)誤，比如：override修飾的父類方法的方法名我們拼寫錯(cuò)了；比如要覆蓋的父類方法的參數(shù)我們寫錯(cuò)了；等等
// 此外，在子類覆蓋父類方法之后，如果我們?cè)谧宇愔芯褪且{(diào)用父類的被覆蓋的方法呢？那就可以使用super關(guān)鍵字，顯式地指定要調(diào)用父類的方法
class Person {
private var name = "leo"
def getName = name
}
class Student extends Person {
private var score = "A"
def getScore = score
override def getName = "Hi, I'm " + super.getName
}
override field
// Scala中，子類可以覆蓋父類的val field，而且子類的val field還可以覆蓋父類的val field的getter方法；只要在子類中使用override關(guān)鍵字即可
class Person {
val name: String = "Person"
def age: Int = 0
}
class Student extends Person {
override val name: String = "leo"
override val age: Int = 30
}
isInstanceOf和asInstanceOf
// 如果我們創(chuàng)建了子類的對(duì)象，但是又將其賦予了父類類型的變量。則在后續(xù)的程序中，我們又需要將父類類型的變量轉(zhuǎn)換為子類類型的變量，應(yīng)該如何做？
// 首先，需要使用isInstanceOf判斷對(duì)象是否是指定類的對(duì)象，如果是的話，則可以使用asInstanceOf將對(duì)象轉(zhuǎn)換為指定類型
// 注意，如果對(duì)象是null，則isInstanceOf一定返回false，asInstanceOf一定返回null
// 注意，如果沒(méi)有用isInstanceOf先判斷對(duì)象是否為指定類的實(shí)例，就直接用asInstanceOf轉(zhuǎn)換，則可能會(huì)拋出異常
class Person
class Student extends Person
val p: Person = new Student
var s: Student = null
if (p.isInstanceOf[Student]) s = p.asInstanceOf[Student]
getClass和classOf
// isInstanceOf只能判斷出對(duì)象是否是指定類以及其子類的對(duì)象，而不能精確判斷出，對(duì)象就是指定類的對(duì)象
// 如果要求精確地判斷對(duì)象就是指定類的對(duì)象，那么就只能使用getClass和classOf了
// 對(duì)象.getClass可以精確獲取對(duì)象的類，classOf[類]可以精確獲取類，然后使用==操作符即可判斷
class Person
class Student extends Person
val p: Person = new Student
p.isInstanceOf[Person]
p.getClass == classOf[Person]
p.getClass == classOf[Student]
使用模式匹配進(jìn)行類型判斷
// 但是在實(shí)際開發(fā)中，比如spark的源碼中，大量的地方都是使用了模式匹配的方式來(lái)進(jìn)行類型的判斷，這種方式更加地簡(jiǎn)潔明了，而且代碼得可維護(hù)性和可擴(kuò)展性也非常的高
// 使用模式匹配，功能性上來(lái)說(shuō)，與isInstanceOf一樣，也是判斷主要是該類以及該類的子類的對(duì)象即可，不是精準(zhǔn)判斷的
class Person
class Student extends Person
val p: Person = new Student
p match {
case per: Person => println("it's Person's object")
case _ => println("unknown type")
}
protected
// 跟java一樣，scala中同樣可以使用protected關(guān)鍵字來(lái)修飾field和method，這樣在子類中就不需要super關(guān)鍵字，直接就可以訪問(wèn)field和method
// 還可以使用protected[this]，則只能在當(dāng)前子類對(duì)象中訪問(wèn)父類的field和method，無(wú)法通過(guò)其他子類對(duì)象訪問(wèn)父類的field和method
class Person {
protected var name: String = "leo"
protected[this] var hobby: String = "game"
}
class Student extends Person {
def sayHello = println("Hello, " + name)
def makeFriends(s: Student) {
println("my hobby is " + hobby + ", your hobby is " + s.hobby)
}
}
調(diào)用父類的constructor
// Scala中，每個(gè)類可以有一個(gè)主constructor和任意多個(gè)輔助constructor，而每個(gè)輔助constructor的第一行都必須是調(diào)用其他輔助constructor或者是主constructor；因此子類的輔助constructor是一定不可能直接調(diào)用父類的constructor的
// 只能在子類的主constructor中調(diào)用父類的constructor，以下這種語(yǔ)法，就是通過(guò)子類的主構(gòu)造函數(shù)來(lái)調(diào)用父類的構(gòu)造函數(shù)
// 注意！如果是父類中接收的參數(shù)，比如name和age，子類中接收時(shí)，就不要用任何val或var來(lái)修飾了，否則會(huì)認(rèn)為是子類要覆蓋父類的field
class Person(val name: String, val age: Int)
class Student(name: String, age: Int, var score: Double) extends Person(name, age) {
def this(name: String) {
this(name, 0, 0)
}
def this(age: Int) {
this("leo", age, 0)
}
}
匿名內(nèi)部類
// 在Scala中，匿名子類是非常常見，而且非常強(qiáng)大的。Spark的源碼中也大量使用了這種匿名子類。
// 匿名子類，也就是說(shuō)，可以定義一個(gè)類的沒(méi)有名稱的子類，并直接創(chuàng)建其對(duì)象，然后將對(duì)象的引用賦予一個(gè)變量。之后甚至可以將該匿名子類的對(duì)象傳遞給其他函數(shù)。
class Person(protected val name: String) {
def sayHello = "Hello, I'm " + name
}
val p = new Person("leo") {
override def sayHello = "Hi, I'm " + name
}
def greeting(p: Person { def sayHello: String }) {
println(p.sayHello)
}
抽象類
// 如果在父類中，有某些方法無(wú)法立即實(shí)現(xiàn)，而需要依賴不同的子來(lái)來(lái)覆蓋，重寫實(shí)現(xiàn)自己不同的方法實(shí)現(xiàn)。此時(shí)可以將父類中的這些方法不給出具體的實(shí)現(xiàn)，只有方法簽名，這種方法就是抽象方法。
// 而一個(gè)類中如果有一個(gè)抽象方法，那么類就必須用abstract來(lái)聲明為抽象類，此時(shí)抽象類是不可以實(shí)例化的
// 在子類中覆蓋抽象類的抽象方法時(shí)，不需要使用override關(guān)鍵字
abstract class Person(val name: String) {
def sayHello: Unit
}
class Student(name: String) extends Person(name) {
def sayHello: Unit = println("Hello, " + name)
}
抽象field
// 如果在父類中，定義了field，但是沒(méi)有給出初始值，則此field為抽象field
// 抽象field意味著，scala會(huì)根據(jù)自己的規(guī)則，為var或val類型的field生成對(duì)應(yīng)的getter和setter方法，但是父類中是沒(méi)有該field的
// 子類必須覆蓋field，以定義自己的具體field，并且覆蓋抽象field，不需要使用override關(guān)鍵字
abstract class Person {
val name: String
}
class Student extends Person {
val name: String = "leo"
}
面向?qū)ο缶幊讨甌rait
課程大綱
1、trait基礎(chǔ)知識(shí)
1-1 將trait作為接口使用
1-2 在trait中定義具體方法
1-3 在trait中定義具體字段
1-4 在trait中定義抽象字段
2、trait高級(jí)知識(shí)
2-1 為實(shí)例對(duì)象混入trait
2-2 trait調(diào)用鏈
2-3 在trait中覆蓋抽象方法
2-4 混合使用trait的具體方法和抽象方法
2-5 trait的構(gòu)造機(jī)制
2-6 trait字段的初始化
2-7 讓trait繼承類
將trait作為接口使用
// Scala中的Triat是一種特殊的概念
// 首先我們可以將Trait作為接口來(lái)使用，此時(shí)的Triat就與Java中的接口非常類似
// 在triat中可以定義抽象方法，就與抽象類中的抽象方法一樣，只要不給出方法的具體實(shí)現(xiàn)即可
// 類可以使用extends關(guān)鍵字繼承trait，注意，這里不是implement，而是extends，在scala中沒(méi)有implement的概念，無(wú)論繼承類還是trait，統(tǒng)一都是extends
// 類繼承trait后，必須實(shí)現(xiàn)其中的抽象方法，實(shí)現(xiàn)時(shí)不需要使用override關(guān)鍵字
// scala不支持對(duì)類進(jìn)行多繼承，但是支持多重繼承trait，使用with關(guān)鍵字即可
trait HelloTrait {
def sayHello(name: String)
}
trait MakeFriendsTrait {
def makeFriends(p: Person)
}
class Person(val name: String) extends HelloTrait with MakeFriendsTrait with Cloneable with Serializable {
def sayHello(name: String) = println("Hello, " + name)
def makeFriends(p: Person) = println("Hello, my name is " + name + ", your name is " + p.name)
}
在Trait中定義具體方法
// Scala中的Triat可以不是只定義抽象方法，還可以定義具體方法，此時(shí)trait更像是包含了通用工具方法的東西?// 有一個(gè)專有的名詞來(lái)形容這種情況，就是說(shuō)trait的功能混入了類
// 舉例來(lái)說(shuō)，trait中可以包含一些很多類都通用的功能方法，比如打印日志等等，spark中就使用了trait來(lái)定義了通用的日志打印方法
trait Logger {
def log(message: String) = println(message)
}
class Person(val name: String) extends Logger {
def makeFriends(p: Person) {
println("Hi, I'm " + name + ", I'm glad to make friends with you, " + p.name)
log("makeFriends methdo is invoked with parameter Person[name=" + p.name + "]")
}
}
在Trait中定義具體字段
// Scala中的Triat可以定義具體field，此時(shí)繼承trait的類就自動(dòng)獲得了trait中定義的field
// 但是這種獲取field的方式與繼承class是不同的：如果是繼承class獲取的field，實(shí)際是定義在父類中的；而繼承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.")
}
在Trait中定義抽象字段
// Scala中的Triat可以定義抽象field，而trait中的具體方法則可以基于抽象field來(lái)編寫
// 但是繼承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!")
}
}
為實(shí)例混入trait
// 有時(shí)我們可以在創(chuàng)建類的對(duì)象時(shí)，指定該對(duì)象混入某個(gè)trait，這樣，就只有這個(gè)對(duì)象混入該trait的方法，而類的其他對(duì)象則沒(méi)有
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調(diào)用鏈
// Scala中支持讓類繼承多個(gè)trait后，依次調(diào)用多個(gè)trait中的同一個(gè)方法，只要讓多個(gè)trait的同一個(gè)方法中，在最后都執(zhí)行super.方法即可
// 類中調(diào)用多個(gè)trait中都有的這個(gè)方法時(shí)，首先會(huì)從最右邊的trait的方法開始執(zhí)行，然后依次往左執(zhí)行，形成一個(gè)調(diào)用鏈條
// 這種特性非常強(qiáng)大，其實(shí)就相當(dāng)于設(shè)計(jì)模式中的責(zé)任鏈模式的一種具體實(shí)現(xiàn)依賴
trait Handler {
def handle(data: String) {}
}
trait DataValidHandler extends Handler {
override def handle(data: String) {
println("check data: " + data)
super.handle(data)
}
}
trait SignatureValidHandler extends Handler {
override def handle(data: String) {
println("check signature: " + data)
super.handle(data)
}
}
class Person(val name: String) extends SignatureValidHandler with DataValidHandler {
def sayHello = { println("Hello, " + name); handle(name) }
}
在trait中覆蓋抽象方法
// 在trait中，是可以覆蓋父trait的抽象方法的
// 但是覆蓋時(shí)，如果使用了super.方法的代碼，則無(wú)法通過(guò)編譯。因?yàn)閟uper.方法就會(huì)去掉用父trait的抽象方法，此時(shí)子trait的該方法還是會(huì)被認(rèn)為是抽象的
// 此時(shí)如果要通過(guò)編譯，就得給子trait的方法加上abstract override修飾
trait Logger {
def log(msg: String)
}
trait MyLogger extends Logger {
abstract override def log(msg: String) { super.log(msg) }
}
混合使用trait的具體方法和抽象方法
// 在trait中，可以混合使用具體方法和抽象方法
// 可以讓具體方法依賴于抽象方法，而抽象方法則放到繼承trait的類中去實(shí)現(xiàn)
// 這種trait其實(shí)就是設(shè)計(jì)模式中的模板設(shè)計(jì)模式的體現(xiàn)
trait Valid {
def getName: String
def valid: Boolean = {
getName == "leo"
}
}
class Person(val name: String) extends Valid {
println(valid)
def getName = name
}
trait的構(gòu)造機(jī)制
// 在Scala中，trait也是有構(gòu)造代碼的，也就是trait中的，不包含在任何方法中的代碼
// 而繼承了trait的類的構(gòu)造機(jī)制如下：1、父類的構(gòu)造函數(shù)執(zhí)行；2、trait的構(gòu)造代碼執(zhí)行，多個(gè)trait從左到右依次執(zhí)行；3、構(gòu)造trait時(shí)會(huì)先構(gòu)造父trait，如果多個(gè)trait繼承同一個(gè)父trait，則父trait只會(huì)構(gòu)造一次；4、所有trait構(gòu)造完畢之后，子類的構(gòu)造函數(shù)執(zhí)行
class Person { println("Person's constructor!") }
trait Logger { println("Logger's constructor!") }
trait MyLogger extends Logger { println("MyLogger's constructor!") }
trait TimeLogger extends Logger { println("TimeLogger's constructor!") }
class Student extends Person with MyLogger with TimeLogger {
println("Student's constructor!")
}
trait field的初始化
// 在Scala中，trait是沒(méi)有接收參數(shù)的構(gòu)造函數(shù)的，這是trait與class的唯一區(qū)別，但是如果需求就是要trait能夠?qū)ield進(jìn)行初始化，該怎么辦呢？只能使用Scala中非常特殊的一種高級(jí)特性——提前定義
trait SayHello {
val msg: String
println(msg.toString)
}
class Person
val p = new {
val msg: String = "init"
} with Person with SayHello
class Person extends {
val msg: String = "init"
} 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，此時(shí)這個(gè)class就會(huì)成為所有繼承該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)
}
}
