不完全定義的類或特質的成員為抽象成員。抽象成員將被聲明類的子類實現(xiàn)怠蹂。
四種抽象成員：val、var、方法及類型

抽象類型val
定義形式：

//指定了val的名稱和類型氢烘，不指定值。
val initial:String
//值必須由子類的具體val定義提供
 class Concrete extends Abstract {
    type T = String
    def transform(x: String) = x + x
    val initial = "hi"
    var current = initial
  }
//抽象的val聲明類似于抽象的無參數(shù)方法聲明
def initial:String

抽象的val限制了合法的實現(xiàn)方法：任何實現(xiàn)都必須是val類型的定義家厌，不可以是var或def播玖。

//重寫的抽象val及無參數(shù)方法
object DefOverVal {
  abstract class Fruit {
    val v: String // `v' for value
    def m: String // `m' for method
  }
  
  abstract class Apple extends Fruit {
    val v: String
    val m: String // 可以用val重寫def
  }
  
  abstract class BadApple extends Fruit {
    def v: String // 錯誤：不能用def重寫val
    def m: String
  }
}

抽象var

object AbstractTime {
//只聲明名稱和類型，沒有初始值饭于。
  trait AbstractTime1 {
    var hour: Int
    var minute: Int
  }

//抽象var擴展為getter和setter方法
  trait AbstractTime2 {
    def hour: Int          // getter for `hour'
    def hour_=(x: Int)     // setter for `hour'
    def minute: Int        // getter for `minute'
    def minute_=(x: Int)   // setter for `minute'
  }


  // these traits combine with no conflict
  class AbstractTime extends AbstractTime1 with AbstractTime2 {
    var hour: Int = 10
    var minute: Int = 10
  }
}

初始化抽象val

object Misc {
  object Obj1 {
//參數(shù)化特質的方式就是通過需要在子類中實現(xiàn)的抽象val完成
    trait RationalTrait { 
      val numerArg: Int 
      val denomArg: Int 
    } 
//實例化特質蜀踏，實現(xiàn)抽象的val定義
    new RationalTrait {
      val numerArg = 1
      val denomArg = 2
    }

    val expr1 = 1
    val expr2 = 2
//expr1、expr2作為匿名類初始化的一部分計算掰吕，匿名類的初始化在RationalTrait之后
    new RationalTrait {
      val numerArg = expr1
      val denomArg = expr2
    }

//枚舉類型
    object Color extends Enumeration {
      val Red = Value
      val Green = Value
      val Blue = Value
    }

    import Color._
    val color1 = Red

    object Direction extends Enumeration {
      val North, East, South, West = Value
    }

 //創(chuàng)建具體的貨幣值
    new Currency {
      val amount = 79L
      def designation = "USD"
    }
//對美元和歐元建模為貨幣類的兩個子類
    abstract class Dollar extends Currency {
      def designation = "USD"
    }
    abstract class Euro extends Currency {
      def designation = "Euro"
    }

    abstract class CurrencyZone {
      type Currency <: AbstractCurrency
      def make(x: Long): Currency
      abstract class AbstractCurrency {
        val amount: Long
        def designation: String 
        def + (that: Currency): Currency = 
          make(this.amount + that.amount)
        def * (x: Double): Currency = 
          make((this.amount * x).toLong)
      }
    }

    object US extends CurrencyZone {
      abstract class Dollar extends AbstractCurrency {
        def designation = "USD"
      }
      type Currency = Dollar
      def make(x: Long) = new Dollar { val amount = x }
    }
  }

  object Obj2 {
//使用了抽象val的特質
    trait RationalTrait { 
      val numerArg: Int 
      val denomArg: Int 
      require(denomArg != 0)
      private val g = gcd(numerArg, denomArg)
      val numer = numerArg / g
      val denom = denomArg / g
      private def gcd(a: Int, b: Int): Int = 
        if (b == 0) a else gcd(b, a % b)
      override def toString = numer +"/"+ denom
    }
//對象定義中的預初始化字段
    object twoThirds extends {
      val numerArg = 2
      val denomArg = 3
    } with RationalTrait
//類定義中的預初始化字段
    class RationalClass(n: Int, d: Int) extends {
      val numerArg = n
      val denomArg = d
    } with RationalTrait {
      def + (that: RationalClass) = new RationalClass(
        numer * that.denom + that.numer * denom,
        denom * that.denom
      )
    }

    object Color extends Enumeration {
      val Red, Green, Blue = Value
    }

    abstract class CurrencyZone {
    
      type Currency <: AbstractCurrency
      def make(x: Long): Currency
    
      abstract class AbstractCurrency {
        val amount: Long
        def designation: String 
    
        def + (that: Currency): Currency = 
          make(this.amount + that.amount)
        def * (x: Double): Currency = 
          make((this.amount * x).toLong)
        def - (that: Currency): Currency = 
          make(this.amount - that.amount)
        def / (that: Double) = 
          make((this.amount / that).toLong)
        def / (that: Currency) = 
          this.amount.toDouble / that.amount
    
        def from(other: CurrencyZone#AbstractCurrency): Currency = 
          make(Math.round(
            other.amount.toDouble * Converter.exchangeRate
              (other.designation)(this.designation)))
    
        private def decimals(n: Long): Int = 
          if (n == 1) 0 else 1 + decimals(n / 10)
    
        override def toString = 
          ((amount.toDouble / CurrencyUnit.amount.toDouble)
           formatted ("%."+ decimals(CurrencyUnit.amount) +"f")
           +" "+ designation)
      }
    
      val CurrencyUnit: Currency
    }

    object Converter {
//帶有匯率表的轉換器對象
      var exchangeRate = Map(
        "USD" -> Map("USD" -> 1.0   , "EUR" -> 0.7596, 
                     "JPY" -> 1.211 , "CHF" -> 1.223),
        "EUR" -> Map("USD" -> 1.316 , "EUR" -> 1.0   , 
                     "JPY" -> 1.594 , "CHF" -> 1.623),
        "JPY" -> Map("USD" -> 0.8257, "EUR" -> 0.6272, 
                     "JPY" -> 1.0   , "CHF" -> 1.018),
        "CHF" -> Map("USD" -> 0.8108, "EUR" -> 0.6160, 
                     "JPY" -> 0.982 , "CHF" -> 1.0  )
      )
    }
  }

  class Outer {
    class Inner
  }
}

抽象類型

object Animals {
//用抽象類型建模合適的食物
  class Food
  abstract class Animal {
    type SuitableFood <: Food
    def eat(food: SuitableFood)
  }

  class Grass extends Food
//在子類中實現(xiàn)抽象類型
  class Cow extends Animal {
    type SuitableFood = Grass
    override def eat(food: Grass) {}
  }

}

路徑依賴類型

//不同的路徑產生不同類型
 class DogFood extends Food
  class Dog extends Animal {
    type SuitableFood = DogFood
    override def eat(food: DogFood) {}
  }

懶加載val

//讓系統(tǒng)本身管理初始化的順序
//通過懶加載 val初始化特征
 trait LazyRationalTrait { 
    val numerArg: Int 
    val denomArg: Int 
    lazy val numer = numerArg / g
    lazy val denom = denomArg / g
    override def toString = numer +"/"+ denom
    private lazy val g = {
      require(denomArg != 0)
      gcd(numerArg, denomArg)
    }
    private def gcd(a: Int, b: Int): Int = 
      if (b == 0) a else gcd(b, a % b)
  }