要点如下:
1. Scala中类只能继承一个超类，可以扩展任意数量的特质
2. 与Java接口不同， Scala特质可以提供方法和字段的实现
3. 当将多个特质叠加使用的时候，顺序很重要——其方法先被执行的特质 排在更后面。
1. Java 接口和 Scala 特质
1.1 Java 接口
在学习Scala特质之前，我们先来复习一下Java接口。
Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java抽象类更抽象化。
Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public、静态的和final属性。
从java8开始接口里可以有静态方式，用static修饰，但是接口里的静态方法的修饰符只能是public，且默认是public。java8里，除了可以在接口里写静态方法，还可以写非静态方法，但是必须用default修饰，且只能是public，默认也是public。默认方法可以被继承。但是要注意，如果继承了两个接口里面的默认方法一样的话，那么必须重写。接口可以被实现，但是无法被实例化。
1.2 Scala特质
Scala Trait(特质) 相当于 Java 的接口，实际上它比接口还功能强大。与接口不同的是，它还可以定义属性和方法的实现。
Trait定义的方式与类类似，但它使用的关键字是 trait
例：
trait A {
val num: Int = 1
}
2. Scala类没有多继承
问题：为什么Scala不支持多重继承呢？
接下来我们看一个例题：
class A{
val id: Int = 01
}
class B {
val id: Int = 02
}
假设可以有:
class C extends A， B {
...
}
问题：要求返回id时，该返回哪一个呢?
这就引出了菱形继承问题：
对于 class A 中的字段， class D 从 B 和 C 都得到了一份，这两个字段怎么得到和被构造呢?这样的情况显然是不合理的。
如果只是把毫不相关的类组装在一起，多继承不会出现问题，但如果这些类具备某些共同的字段或方法，则多继承就会出现问题，即多重继承会产生菱形继承问题。
那么，如何解决这种问题呢？
在Java中取而代之的是接口，而Scala中则是特质。
一般情况下Scala的类只能够继承一个超类，但是如果是Trait的话就可以继承多个，从结果来看就是实现了多重继承。
Scala 中类只能继承一个超类（Java中称为父类），可以扩展任意数量的特质，与Java接口相比，Scala 的特质可以有具体方法和抽象方法； Java 的抽象基类中也有具体方法和抽象方法，但Java的接口不能有具体方法。
扩展：什么时候应该使用特质而不是抽象类？
如果你想定义一个类似接口的类型，你可能会在特质和抽象类之间难以取舍。这两种形式都可以让你定义一个类型的一些行为，并要求继承者定义一些其他行为。
一些经验法则：
Ø 优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
Ø 如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行。
例如，你不能说trait t(i:Int) {}，参数i是非法的。
3. 当做接口使用的特质
首先，让我们从熟悉的内容开始。Scala特质可以完全像Java接口一样工作。
例子：
trait Logger {
//abstractmethod, but no abstract declare required
def log(msg: String) //没有实现，这是个抽象方法
}
注意：你不需要将抽象方法声明为 abstract，特质中未被实现的方法默认就是抽象方法。
子类可以给出实现：
class ConsoleLogger extends Logger {
//在重写特质的抽象方法时不需要给出override关键字
def log(msg: String){
println(msg)
}
}
4. 带有具体实现的特质
trait Logger {
def log(msg:String) // 抽象方法
def printAny(k: Any){ // 具体方法
println("具体实现")
}
让特质混有具体行为有一个弊端. 当特质改变时，所有混入该特质的类都必须重新编译。
5. 带有特质的对象
Scala可以在创建对象时添加特质，这是Java接口所不具备的特性。
特质可以将对象原本没有的方法与字段加入对象中，如果特质和对象改写了同一超类的方法，则排在右边的先被执行。
例：
// Feline 猫科动物
abstract class Feline {
def say()
}
trait Tiger extends Feline {
// 在特质中重写抽象方法，需要在方法前添加 abstract override 2个关键字
abstract overridedef say() = println("嗷")
def king() =println("I'm king of here")
}
class Cat extends Feline {
override def say() =println("喵")
}
object Test extends App {
val feline = new Catwith Tiger //在对象构造时混入特质
feline.say // Cat 和 Tiger 都与 say 方法，调用时从右往左调用，是 Tiger 在叫
feline.king// 可以看到即使没有 cat 中没有 king 方法， Tiger 特质也能将自己的方法混入 Cat 中
}
输出结果:
6. 特质的叠加
就像Java Class可以实现多个接口一样，Scala Class也可以叠加多个特质。
6.1 with 关键字添加额外特质
类可以通过 extends 关键字继承特质，如果需要的特质不止一个，通过 with 关键字添加额外特质。
例： Class A extends Bwith C with D {…}
6.2特质的处理顺序
一般来说，特质从最后一个开始被处理。这对于需要分阶段加工处理某个值的场景很有用.
例：
class A {…}
trait B {…}
trait C {…}
object test extends App{
val a = new A with Bwith C
}
实际上，一个方法调用的是特质层级中的那一个特质，具体是哪一个，取决于特质添加的顺序。一般来说，特质从最后一个开始被处理。
在上面这个例子中，特质C中的方法首先会先被执行。
7. 特质中的字段
特质中的字段可以是具体的也可以是抽象的.
7.1 具体字段
如果给出了初始值那么字段就是具体的.
trait Ability {
val run ="running" // 具体字段
…
}
7.2抽象字段
如果未出了初始值那么字段就是抽象的。特质中未被初始化的字段在具体的子类中必须被重写。
trait Ability {
val swim: String //抽象字段
def ability(msg: String)= println(msg + swim) //方法用了swim字段
}
class Cat extends Ability {
val swim ="swimming"
}
object Test extends App{
val f = new Cat withAbility
val fish:String ="fish"
f.ability(fish)
}
运行结果：
这种提供特质参数的方式在临时构造某种对象很有利，很灵活，按需定制.
8. 特质的构造顺序
在scala中除了对象（object）以外，其他的单位，例如类，特质等都有构造器。特质的构造器，由字段的初始化和其他特质体中的语句构成。
例：
trait FileLogger extends Logger｛
val out =new PrintWriter(“app.log”)//这是特质构造器的一部分
out.println(“#”+newDate().Tostring) //这也是特质构造器的一部分
val filename: String// 构造器一部分
valout = new PrintWriter(filename) // 构造器的一部分
deflog(msg: String){ out.println(msg);out.flush() }
｝
这些语句在任何混入该特质的对象在构造时都会被执行。
在这么多种的构造器中，在程序执行的过程中，构造器也有其特定的执行过程，具体的执行顺序如下：
1. 调用超类的构造器；
2. 特质构造器在超类构造器之后、类构造器之前执行；
3. 特质由左到右被构造；
4. 每个特质当中，父特质先被构造；
5. 如果多个特质共有一个父特质，父特质不会被重复构造
6. 所有特质被构造完毕，子类被构造。
举例考虑一下下面这个类构造器将按什么顺序执行：
trait Logger{…}
trait ShortLogger extends Logger{…}
trait TimestampLogger extends Logger{…}
class Account{…}
class SavingsAccount extends Account with FileLogger with ShortLogger｛…｝
构造器将按如下顺序执行：
1. Account(超类)。
2. Logger(第一个特质的父特质)
3. FileLogger（第一个特质）
4. ShortLogger（第二个特质）
5. SavingsAccount（类）
注意与叠加特质时，特质被处理的顺序区分，一般来说，特质从右向左执行，即从最后一个开始被处理。而特质的构造是从左到右被构造
特质不能有构造器参数. 每个特质都有一个无参构造器. 值得一提的是，缺少构造器参数是特质与类唯一不相同的技术差别. 除此之外，特质可以具有类的所有特性，比如具体的和抽象的字段，以及超类。
特质背后的实现: Scala通过将 trait 翻译成 JVM 的类和接口，关于通过反编译的方式查看 Scala 特质的背后工作方式可以参照 Scala 令人着迷的类设计中介绍的方法，有兴趣的可以看看.
9.总结Java接口 (interface) 与Scala特质 (trait) ：
通过上面对Java接口和Scala特质的学习，我们发现它们之间有很多的相似性，同时也有差别。
9.1相似性：
Java接口和Scala特质都可以包含抽象方法和具体实现(Java8新增了default关键字，可以使接口有自己的默认的实现类，而且还不影响接口的实现类。)
Scala和Java一样都不允许类从多个超类继承，但分别可以叠加多个特质和实现多个接口；
9.2差异性：
Java只能在Class层面添加接口的实现，Scala可以在Class和对象层面“混入”特质。Scala通过在对象层面动态“混入”特质，相比而言具有更大的灵活性。