Scala Trait
大多数的时候，Scala中的trait有点类似于Java中的interface。正如同java中的class可以implement多个interface，scala中的calss也可以extend多个trait。因此你看你会看到类似于这样的代码：
class Woodpecker extends Bird with TreeScaling with Peckingscala的trait具有比java中的interface强大的多的功能，正如同java中的abstract class可以具有一些方法实现一样，scala中的trait也可以拥有implemented methods。但是和java中的abstract class不相同的是，你可以将多个trait糅合到一个class中，也可以控制哪些class可以将trait糅合进去。
trait BaseSoundPlayer {
def play
def close
def pause
def stop
def resume
}如果方法不需要任何的参数的话，那么就可以使用def只declare方法的名字，而不需要（）。当然如果方法需要参数的话，那么和平时一样，加上括号：
trait Dog {
def speak(whatToSay: String)
def wagTail(enabled: Boolean)
}当一个类继承一个trait的时候，使用的是extend关键字，如果需要集成多个trait的时候，那么需要使用extend和with关键字，也就是第一个trait使用extend，后续的都是用with。如下面的例子：
class Mp3SoundPlayer extends BaseSoundPlayer {...}
class Foo extends BaseClass with Trait1 with Trait2 { ...}但是如果一个class已经extend另外一个class了，那么如果还想继承其他的trait的话，都必须使用with:
abstract class Animal {
}
trait WaggingTail {
def startTail { println("tail started") }
def stopTail { println("tail stopped") }
}
trait FourLeggedAnimal {
def walk
def run
}
class Dog extends Animal with WaggingTail with FourLeggedAnimal {
// implementation code here ...
def speak { println("Dog says 'woof'") }
def walk { println("Dog is walking") }
def run { println("Dog is running") }
}如果一个class extends一个trait，如果它并没有全部实现trait中定义的抽象方法，那么这个class就必须标记为abstract。
class Mp3SoundPlayer extends BaseSoundPlayer {
def play { // code here ... }
def close { // code here ... }
def pause { // code here ... }
def stop { // code here ... }
def resume { // code here ... }
}
// must be declared abstract because it does not implement
// all of the BaseSoundPlayer methods
abstract class SimpleSoundPlayer extends BaseSoundPlayer {
def play { ... }
def close { ... }
}另外，trait也可以extend其他的trait
trait Mp3BaseSoundFilePlayer extends BaseSoundPlayer{
def getBasicPlayer: BasicPlayer
def getBasicController: BasicController
def setGain(volume: Double)
}定义一个trait，然后给他定义一个faild并且给初始化值，就意味着让它concrete，如果不给值的话，就会让他abstract。
trait PizzaTrait {
var numToppings: Int // abstract
var size = 14 // concrete
val maxNumToppings = 10 // concrete
}然后对于extends这个PizzaTrait的类中，如果没有给abstract field给值的话，那么就必须标记这个类为abstract、
class Pizza extends PizzaTrait {
var numToppings = 0 // 'override' not needed
size = 16 // 'var' and 'override' not needed
}从上面的例子可以看出，在trait中可以使用var或者val来定义faild，然后在subclass或者trait中不必使用override关键字来重写var faild。但是对于val faild需要使用override关键字。
trait PizzaTrait {
val maxNumToppings: Int
}
class Pizza extends PizzaTrait {
override val maxNumToppings = 10 // 'override' is required
}尽管scala中也有abstract class，但是使用trait更加的灵活.
如果我们想限制那些class可以嵌入trait的话，我们可以使用下面的语法：
trait [TraitName] extends [SuperThing]这样只有extend了SuperThing类型的trait， class， abstract class才能够嵌入TraitName, 比如：
class StarfleetComponent
trait StarfleetWarpCore extends StarfleetComponent
class Starship extends StarfleetComponent with StarfleetWarpCore另外一个例子：
abstract class Employee
class CorporateEmployee extends Employee
class StoreEmployee extends Employee
trait DeliversFood extends StoreEmployee
// this is allowed
class DeliveryPerson extends StoreEmployee with DeliversFood
// won't compile
class Receptionist extends CorporateEmployee with DeliversFood如果我们想使得Trait只能够被继承了特定类型的类型使用的时候，就可以使用下面的样例：
For instance, to make sure a StarfleetWarpCore can only be used in a Starship , mark the StarfleetWarpCore trait like this:
trait StarfleetWarpCore {
this: Starship =>
// more code here ...
}
class Starship
class Enterprise extends Starship with StarfleetWarpCore
trait WarpCore {
this: Starship with WarpCoreEjector with FireExtinguisher =>
}表名WarpCore 只能被同时继承了Starship 、WarpCoreEjector 、WarpCoreEjector 这三个东西的东西嵌入
class Starship
trait WarpCoreEjector
trait FireExtinguisher
// this works
class Enterprise extends Starship
with WarpCore
with WarpCoreEjector
with FireExtinguisher如果我们想限制Trait只能被拥有特定方法的类型所嵌入的话，可以参考下面的例子：
trait WarpCore {
this: { def ejectWarpCore(password: String): Boolean } =>
}只有定义有ejectWarpCore方法的classes才能嵌入WarpCore
class Starship {
// code here ...
}
class Enterprise extends Starship with WarpCore {
def ejectWarpCore(password: String): Boolean = {
if (password == "password") {
println("ejecting core")
true
} else {
false
}
}
}当然也可以要求必须有多个方法：
trait WarpCore {
this: {
def ejectWarpCore(password: String): Boolean
def startWarpCore: Unit
} =>
}
class Starship
class Enterprise extends Starship with WarpCore {
def ejectWarpCore(password: String): Boolean = {
if (password == "password") { println("core ejected"); true } else false
}
def startWarpCore { println("core started") }
}我们可以在object instance创建的时候嵌入Traits。
class DavidBanner
trait Angry {
println("You won't like me ...")
}
object Test extends App {
val hulk = new DavidBanner with Angry
}这个代码将会输出：“You won’t like me ...”
这个技巧对于debug一些东西的时候比较方便：
trait Debugger {
def log(message: String) {
// do something with message
}
}
// no debugger
val child = new Child
// debugger added as the object is created
val problemChild = new ProblemChild with Debugger如果你想在Scala中implement Java interface，看下面的例子；
假定现在有3个java interface:
// java
public interface Animal {
public void speak();
}
public interface Wagging {
public void wag();
}
public interface Running {
public void run();
}我们在Scala中就可以使用类似于下面的写法
// scala
class Dog extends Animal with Wagging with Running {
def speak { println("Woof") }
def wag { println("Tail is wagging!") }
def run { println("I'm running!") }
}