Scala入门2（特质与叠加在一起的特质）

一、介绍

　　参考http://luchunli.blog.51cto.com/2368057/1705025

　　我们知道，如果几个类有某些共通的方法或者字段，那么从它们多重继承时，就会出现麻烦。所以Java被设计成 不支持多重继承，但可以实现任意多的接口。接口只能包含抽象方法，不能包含字段。

　　特质 trait 是Scala中特有的一项特点，不同于C#与Java，如果一定要拿C#与Java中的某项特点作对比的话，最接近的应该是接口，但是C#与Java中的接口是不允许带有方法实现的，而Scala中的Trait是可以带有方法实现的。这样做的好处需要某个trait就拿来用，而不需要重复实现接口。

　　所有的Java接口都可以作为Scala特质来使用。与Java一样，Scala类只能有一个超类，可以有任意数量的特质。

　　特质的定义使用保留字trait，具体语法与类定义类似，除了不能拥有构造参数

trait reset {
    def reset (m : Int, n : Int) = if (m >= n) 1;
}

　　一旦特质被定义了，就可以混入到类中

class week extends reset {......}

　　当要混入多个特质时，利用with保留字

class week extends reset with B with C {......}

　　特质的成员可以是抽象的，而且不需要使用abstract声明。同样，重写特质的抽象方法无需给出override。但是，多个特质重写同一个特质的抽象方法需要给出override。
　　除了在类定义中混入特质外，还可以在特质定义中混入特质

trait reseting extends reset {......}

　　在对象构造时混入特质

val file = new month with reseting

　　特质的构造是有顺序的，从左到右被构造

/**
 * @author lucl
 */
class Teacher {  // 实验用的空类
  println("===============I'm Teacher.");
}  
 
trait TTeacher extends Teacher {
  println("===============I'm TTeacher.")
  def teach;    // 虚方法，没有实现  
}
 
trait TPianoTeacher extends Teacher {
  println("===============I'm TPianoTeacher.")
  def playPiano = {                // 实方法，已实现
    println("I'm playing piano.");
  }
}
 
class PianoPlayingTeacher extends Teacher with TTeacher with TPianoTeacher {
  println("===============I'm PianoPlayingTeacher.")
  def teach = {                   // 定义虚方法的实现
    println("I'm teaching students.");
  }
}
 
object TraitOps {
  def main (args : Array[String]) {
    var p = new PianoPlayingTeacher;
    p.teach;
    p.playPiano;
  }
}
 
/**
===============I'm Teacher.
===============I'm TTeacher.
===============I'm TPianoTeacher.
===============I'm PianoPlayingTeacher.
I'm teaching students.
I'm playing piano.
 */

二、例子

　　我们的例子中定义了一个抽象类Aminal表示所有的动物，然后定义了两个trait Flyable和Swimable分别表示会飞和会游泳两种特征。

　　Aminmal的实现（定义了walk方法，实现了breathe方法）

abstract class Animal {
  def walk(speed : Int);
   
  def breathe () = {
    println("animal breathes.");
  }
}

　　Flyable和Swimable两个 trait的实现

/**
 * @author lucl
 * 有两个方法，一个抽象方法一个已实现方法
 */
trait Flyable {
  def hasFather = true;
  def fly;
}
 
package com.mtrait
 
/**
 * @author lucl
 * 只有一个抽象方法
 */
trait Swimable {
  def swim;
}

　　我们定义一种动物，它既会飞也会游泳，这种动物是鱼鹰 FishEagle

/**
 * @author lucl
 */
class FishEagle extends Animal with Flyable with Swimable {
  /**
   * 实现抽象类的walk方法
   */
  override def walk(speed: Int) = {
    println ("Fish eagle walk with speed : " + speed + ".");
  }
   
  /**
   * 实现trait Flyable的方法
   */
  override def fly = {
    println("Fish eagle fly fast.");
  }
   
  /**
   * 实现trait Swimable的方法
   */
  override def swim {
    println("Fish eagle swim fast.");
  }
}
 
object FishEagle {
  def main (args : Array[String]) {
    val fish = new FishEagle;
    fish.walk(100);
    fish.fly;
    fish.swim;
    println("fish eagle has father ? " + fish.hasFather + ".");
    // println(fish.swim);    // 输出为()
     
    println();
    val flyable : Flyable = fish;
    flyable.fly;
    
    val swimable : Swimable = fish;
    swimable.swim;
  }
}
 
/**
输出结果：
Fish eagle walk with speed : 100.
Fish eagle fly fast.
Fish eagle swim fast.
fish eagle has father ? true.
 
Fish eagle fly fast.
Fish eagle swim fast.
*/

　　trait很强大，抽象类能做的事情，trait都可以做，它的长处在于可以多继承。

　　trait和抽象类的区别在于抽象类是对一个继承链的，类和类之前确实有父子类的继承关系，而trait则如其名字，表示一种特征，可以多继承。

　　在对象中混入trait

/**
 * 单独的日志模块
 * 只是标识要记录日志，但没有明确定义如何记录日志
 */
trait Logger {
  def log (msg : String) {}
}
 
/**
 * 记录日志的具体实现类
 */
trait WriteLogger extends Logger {
  override def log (msg : String) = {println("WriteLogger : " + msg);}
}
 
/**
 * 需要执行的业务操作
 */
trait Action {
  def doAction(action : String);
}
 
class TraitActionImpl extends Action {
  override def doAction(op : String) = println(op);
}
 
class LoggerActionImpl extends Action with Logger {
  override def doAction(op : String) = {
    println(op); 
    // 如果确实需要日志功能但暂不清楚以何种形式记录日志时，可以采用该方法；
    // 当明确了记录日志的方式后，再通过如下在对象中混入trait实现。
    log (op);  
  }
}
 
/**
 * @author lucl
 */
object TraitOps {
  def main (args : Array[String]) {
    // 
    println("===================aaaaaa========================");
    // 类本身与记录日志Logger没有关系，但是在对象中混入trait的代码后，就具备了日志的功能
    val actionA = new TraitActionImpl with WriteLogger;
    val op = "业务操作";
    actionA.doAction(op);
    actionA.log(op);
     
    //
    println("===================bbbbbb========================");
    // 类实现了Logger，但日志记录是空的操作
    val loggerA = new LoggerActionImpl;  
    loggerA.doAction(op);
     
    println("===================cccccc========================");
    // 类实现了Logger，通过在类定义中混入trait实现了自己的记日志的功能
    val loggerB = new LoggerActionImpl with WriteLogger;
    loggerB.doAction(op);
  }
}
 
/**
输出结果：
===================aaaaaa========================
业务操作
WriteLogger : 业务操作
===================bbbbbb========================
业务操作
===================cccccc========================
业务操作
WriteLogger : 业务操作
*/

三、总结

　　简单来说，Scala的trait就是类似于Java的接口。使一个类能实现多种功能。