快速学习Scala之接口

将Trait作为接口使用

Scala中的Triat是一种特殊的概念，可以将Trait作为接口来使用，此时的Triat就与Java中的接口非常类似。在triat中可以定义抽象方法，就与抽象类中的抽象方法一样，只要不给出方法的具体实现即可；类可以使用extends关键字继承trait。注意这里不是implement而是extends。在scala中没有implement的概念，无论继承类还是trait统一都是extends。类继承trait后，必须实现其中的抽象方法，实现时不需要使用override关键字。scala不支持对类进行多继承，但是支持多重继承trait，使用with关键字即可。

/**
 * 定义人种接口
 */
trait Race{
  /**
   * 习俗，抽象方法
   */
  def habitude():Unit
  /**
   * 祖先，抽象方法
   */
  def ancestor():Unit
}

/**
 * 人种实现类，实现Race接口
 */
class RaceImpl(skin : String, lang : String) extends Race{
  def habitude() : Unit = {
    println("habitude 方法需在子类中进行实现")
  }

  def ancestor() : Unit = {
    println("ancestor 方法需在子类中进行实现")
  }
}

在Trait中定义具体方法

Scala中的Triat不只可以定义抽象方法，还可以定义具体方法，此时trait更像是包含了通用工具方法的"抽象类"。有一个专有的名词来形容这种情况，就是说trait的功能混入了类。

/**
 * 定义人种接口
 */
trait Race{
  
  //人种名称，抽象field，需在继承类中覆盖赋值
  val raceName:String
 
  //眼睛的数量，具体field
  val eyes : Int = 2
  
  //胳膊的数量，具体field
  val arms : Int = 2
  
  //腿的数量，具体field
  val legs : Int = 2
  
  /**
   * 习俗
   */
  def habitude():Unit
  /**
   * 祖先
   */
  def ancestor():Unit
  
  /**
   * 睡觉，具体方法
   */
  def sleep()={
    println("每天都要睡上一段时间")
  }
}

定义具体字段

Scala中的Triat可以定义具体field，此时继承trait的类就自动获得了trait中定义的field。但是这种获取field的方式与继承class是不同的：如果是继承class获取的field，实际是定义在父类中的；而继承trait获取的field，就直接被添加到了类中。

定义抽象字段

Scala中的Triat可以定义抽象field，而trait中的具体方法则可以基于抽象field来编写。但是继承trait的类则必须覆盖抽象field提供具体的值。

/**
 * 人种实现类，实现Race接口
 */
class RaceImpl(skin : String, lang : String) extends Race{
    //覆盖Trait中的raceName
    val raceName:String = skin+"人种"
    ...
}

为实例混入trait

有时可以在创建类的对象时指定该对象混入某个trait，这样就只有这个对象混入该trait的方法，而类的其他对象则没有。

/**
 * 喝茶trait
 */
trait Drink{
  def tea()=println("喝茶")
}

...
val race1= new RaceImpl("黄色","汉语")
//race2混入Drink tait，可以调用tea()方法
val race2= new RaceImpl("黄色","汉语") with Drink
race1.ancestor()
race2.tea()

trait调用链

Scala中支持让类继承多个trait后，依次调用多个trait中的同一个方法，只要让多个trait的同一个方法中在最后都执行super.方法即可。类中调用多个trait中都有的这个方法时，首先会从最右边的trait的方法开始执行，然后依次往左形成一个调用链条。这种特性非常强大，相当于设计模式中的责任链模式的一种具体实现。

/**
 * 项目阶段接口
 */
trait Phase {
  //阶段名称，抽象字段
  val phase : String

  //每个阶段做的事情，具体方法，空实现
  def doSomething() : Unit = {}
}

/**
 * 需求阶段
 */
trait RequirementPhase extends Phase {
  //为trait抽象字段赋值
  override val phase : String = "需求阶段"
  /**
   * 实现trait中的抽象方法
   */
  override def doSomething() : Unit = {
    println("主要处理需求阶段相关事务，如需求调研，编写需求文档、需求评审等。")
    super.doSomething()
  }
}

/**
 * 计划阶段
 */
trait PlanningPhase extends Phase {
  //为trait抽象字段赋值
  override val phase : String = "计划阶段"
  /**
   * 实现trait中的抽象方法
   */
  override def doSomething() : Unit = {
    println("主要处理计划阶段相关事务，如编写里程碑计划、开发计划、测试计划，编写计划文档评审等。")
    super.doSomething()
  }
}

/**
 * 设计阶段
 */
trait DesignPhase extends Phase {
  //为trait抽象字段赋值
  override val phase : String = "设计阶段"
  /**
   * 实现trait中的抽象方法
   */
  override def doSomething() : Unit = {
    println("主要处理设计阶段相关事务，如编写技术解决方案、概要设计、数据库设计，设计文档评审等。")
    super.doSomething()
  }
}

/**
 * 开发阶段
 */
trait DevelopmentPhase extends Phase {
  //为trait抽象字段赋值
  override val phase : String = "开发阶段"
  /**
   * 实现trait中的抽象方法
   */
  override def doSomething() : Unit = {
    println("主要处理开发阶段相关事务，如编码。")
    super.doSomething()
  }
}

/**
 * 测试阶段
 */
trait TestPhase extends Phase {
  //为trait抽象字段赋值
  override val phase : String = "测试阶段"
  /**
   * 实现trait中的抽象方法
   */
  override def doSomething() : Unit = {
    println("主要处理测试阶段相关事务，如编写测试用例文档、测试、编写测试报告、文档评审等。")
    super.doSomething()
  }
}

/**
 * 验收阶段
 */
trait AcceptancePhase extends Phase {
  //为trait抽象字段赋值
  override val phase : String = "验收阶段"
  /**
   * 实现trait中的抽象方法
   */
  override def doSomething() : Unit = {
    println("主要处理验收阶段相关事务，如开发验收，文档验收、项目交付等。")
    super.doSomething()
  }
}

/**
 * 项目类，继承各个阶段的trait
 */
class Project extends AcceptancePhase 
              with TestPhase 
              with DevelopmentPhase 
              with DesignPhase 
              with PlanningPhase 
              with RequirementPhase {
  //定义process方法
  def process() : Unit = {
    //调用trait中的方法
    doSomething()
  }
}

object Project{
  def main(args: Array[String]): Unit = {
    val p = new Project()
    p.process()
  }
}

在trait中覆盖抽象方法

在trait中是可以覆盖父trait的抽象方法的。覆盖时如果使用了super.方法的代码则无法通过编译，因为super.方法就会去掉用父trait的抽象方法，此时子trait的该方法还是会被认为是抽象的。如果要通过编译，就得给子trait的方法加上abstract override修饰。

混合使用具体方法和抽象方法

在trait中可以混合使用具体方法和抽象方法。可以让具体方法依赖于抽象方法，而抽象方法则放到继承trait的类中去实现，这种trait其实就是设计模式中的模板设计模式的体现。

trait的构造机制

在Scala中trait也是有构造代码的，也就是trait中的不包含在任何方法中的代码。而继承了trait的类的构造机制如下：

父类的构造函数执行；
trait的构造代码执行，多个trait从左到右依次执行；
构造trait时会先构造父trait，如果多个trait继承同一个父trait，则父trait只会构造一次；
所有trait构造完毕之后，子类的构造函数执行

继承class

在Scala中trait也可以继承自class，此时这个class就会成为所有继承该trait的类的父类。