《快学Scala》第十章——特质

一.本章要点

类可以实现任意数量的特质
特质可以要求实现它们的类具备特定的字段，方法或超类
和Java接口不同，Scala特质可以提供方法和字段实现
当你将多个特质叠加在一起时，顺序很重要——其方法先被执行的特质排在更后面

二.为什么没有多重继承

　　Scala和Java一样，不允许使用多重继承（如果继承的多个超类具备某些共通的方法或字段，会引起混乱，还有可能引起菱形继承问题）;

　　Java中可以实现任意多个接口（接口中只能有抽象方法，且不能有字段，Java中使用抽象基类和接口的做法让可以实现一些方法[治标不治本，同时扩展两个基类会出问题]），Scala提供“特质”而不是接口，特质可以同时拥有抽象方法和具体方法，类可以实现多个特质。

三.当作接口使用的特质

trait Logger{
def log(msg:String) //抽象方法
}


//子类实现(使用extends)
class ConsoleLogger extends Logger{
def log(msgLString){ //不需要写override
println(msg)
}

}

　　注：Scala并没有一个特殊的关键字标记特质的实现;

　　　　使用with关键字添加多个特质（extends只需要一个，后面是一个整体，如class ConsoleLogger extends Logger with Cloneable with Serializable）

四.带有具体实现的特质

trait Logger{
def log(msg:String) {
println(msg)}
}


//子类实现
class SavingAccount extends Account wirh Logger{
def withdraw(amount:Double){
if(amount>balance) log("Not enugth")
}
else ....
}

　　注：

　　　　这就是具有具体实现的特质，但是让特质具有具体行为有一个弊端：当特质改变时，所有混入该特质的类都必须重新编译。

五.带有特质的对象

　　可以在构造对象时混入特质（可根据不同对象需要加入不同特质），例：

trait Logger{
def log(msg:String) {
}
}


//子类实现
class SavingAccount extends Account wirh Logger{
def withdraw(amount:Double){
if(amount>balance) log("Not enugth")
}
else ....
}

trait MyLogger extends Logger{
def log(msg:String) {println(msg)
}
}

//实例化加特质
val acct=new SavingAccount with MyLogger

六.叠加在一起的特质

　　可以为对象或类添加多个互相调用的特质，对于分阶段加工处理某个值的场景非常有用。

　　super.log调用的是特质等级中的下一个特质（根据特质的添加顺序决定）：

　　特质super.xxx执行的方法只依赖于这些特质的对象或类给出的顺序（更加灵活）;

　　可以控制具体是哪一个特质的方法被调用：super[ConsoleLogger].log(...)，这里的类型必须是直接超类型，不能使用继承等级更远的特质或类。

七.在特质中重写抽象的方法

traint Logger{
def log(msg:String) //抽象方法
}
//错误的
trait TimestampLogger extends Logger{
override def log(msg:String){//重写抽象方法
super.log(new  java.util.Date()+" "+msg)

}
}

//正确使用
trait TimestampLogger extends Logger{
abstract override def log(msg:String){//重写抽象方法
super.log(new  java.util.Date()+" "+msg)

}
}

　　Logger.log没有实现，Scala认为TimestampLogger依旧是抽象的，它需要混入一个具体的log方法，因此必须使用abstract和override关键字。

八.当做富接口使用的特质

　　特质中可以使用抽象方法和具体方法（相当于Java中接口和抽象类一起实现），例：

trait Logger{
def log(msg:String)
def info(msg:String){log("Info:"+msg)}
def warn(msg:String){log("warn:"+msg)}
def service(msg:String){log("service:"+msg)}


}

九.特质中的具体字段

　　特质中的字段可以是具体的，也可以是抽象的。

　　对于特质中的每一个字段，使用该特质的类都会获得特质中的字段（不是继承，只是简单的加入）。

十.特质中的抽象字段

　　特质中未被初始化的字段在具体的子类中必须重写（不需要写override）。

十一.特质构造顺序

　　和类一样，特质也有构造器，由字段的初始化和其他特质体中的语句构成。

　　特质中的构造器语句在任何混入该特质的对象在构造时执行。

　　构造器执行顺序：

1. 首先调用超类的构造器;
2. 特质构造器在超类构造器之后，类构造器之前执行;
3. 特质由左到右被构造;
4. 每个特质当中，父特质先被构造;
5. 如果多个特质共有一个父特质，而那个父特质已经被构造，则不会再次构造;
6. 所有特质构造完毕，子类被构造

例

　　注：构造器的顺序是类的线性化的反向

十二.初始化特质中的字段

　　特质不能有够构造器参数（类和特质的唯一区别），每个特质都有一个无参书的构造器。

　　如果需要定制（如日志文件名），可以使用一个抽象字段来存文件名，注意这样的陷阱：

traint FileLogger extends Logger{
val filename:String
val out=new PrintStream(filename)
def log(msg:String){
out.println(msg);out.rlush()
}
}


//错误的（FileLogger的构造器先于子类构造器执行，所以FileLogger的构造器会抛出一个空指针异常）
 acct =new SavingsAccount with FileLogger(){
val filename="myapp.log"
}
//解决方法一：可以使用“提前定义“解决
val acct=new {//new之后的提前定义块
val filename="myapp.log"
}with SavingsAccount with FileLoggere
//类中使用提前定义
class SavingAccount extends {//extends后的提前定义块
val filename="myapp.log"
}with Account with FileLogger{
...//SavingsAccount的实现
}
//解决方法二：使用懒值（并不是那么高效）
trait FileLogger extends Logger{
val filename:String
lazy val out=new PrintStream(filename)
def log(msg:String){out.println(msg)//不需要重写override}}

十三.扩展类的特质

　　特质可以扩展另一个特质，同时特质也可以扩展类（这个类将会自动成为所有混入该特质的超类），例：

//LoggedException 扩展自Exception类

trait LoggedException extends Exception with Logged{
def log(){
log(getMessage())
}
}

//物质的超类也称为这个类的超类
class UnhappyException extends LogedException{

//该类扩展自一个特质
override def getMessage()="test"
}
//IOException是Exception的子类
class UnhappyException extends IOException with LoggedException{
}

　　注：如果我们的类已经扩展了另一个类，只要它是特质的超类的子类即可，如果扩展了一个不相关的类，那么就不能混入这个特质了。

十四.自身类型

　　当特质扩展类时，编译器能确保所有混入这一特质的类都认这个类为超类，自身类型也能保证。

　　自身类型定义如下：this:类型=>，例：

//该特质并不扩展Exception类，而是有一个自身类型Exception，因此只能混入Exception的子类，this一定是一个Excption
trait LoggedException extends Logged{
this :Exception=>{
def log(){
log(getMessage())}}}

　　注：自身类型和带有超类型的特质很像，都能确保混入该特质的类都能使用某个特定类型的特性，在某些情况下，自身类型比超类版更灵活，而且自身类型可以解决循环依赖（有两个彼此需要的特质时循环依赖就产生了）；

　　　　自身类型也可以处理结构类型：只给出类必须拥有的方法，而不是类名称，例：

trait LoggedException extends Logged{
this :def getMessage():String=>{
def log(){
log(getMessage())}}}

十五.背后发生了什么

　　Scala需要将特质翻译成JVM的类和接口。

　　只有抽象方法的特质，例：

//Scala
trait Logger{
def log(msg:String)
}
//JVM对应生成的Java接口
public interface Logger{
void log(String msg);
}

　　具有具体方法的特质，Scala会为我们创建伴生类，该伴生类用静态方法存放特质的方法，例：

//Scala代码
trait ConsoleLoggger extends Logger{
def log(msg:String){println(msg)}
}
//JVM对应Java代码
public interface ConsoleLogger extends Logger{
//生成的Java接口
void log(String msg);
}

public class ConsoleLogger$class{
//生成的Java伴生类，注意伴生类中不会有任何字段
public static void log(ConsoleLogger self,String msg){
System.out.println(msg);
}
}

　　伴生类中不会有任何字段，特质中的字段对应接口中的抽象的getter和setter方法，例：

//Scala代码
trait ShortLogger extends Logger{
val maxLength=15//具体字段
...}
//Java对应
public interface ShortLogger extends Logger{
public abstract int maxLength();
public abstract void weired_prefix$maxLength_$eq(int);
...    
}


public class ShortLogger$class{
//以weird开头的setter方法是需要的，用来初始化该字段
//当特质混入类时，类会有一个setter和getter方法和maxLength字段，类的构造器会调用初始化方法
public void $init$(ShortLogger self){
self.weird_prefix$maxLength_$eq(15)}
}