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)}
} 

十六.练习

 

 

 

 

 

 

posted @ 2019-11-30 22:16  biu嘟  阅读(394)  评论(0编辑  收藏  举报