Scala 的抽象成员

Scala 的抽象成员

抽象成员（Abstract Members）

类或是特质的成员是否是抽象的，主要取决于该成员在其中是否有完整的定义
抽象成员在类或特质中被声明，由子类来进行实现

除了抽象方法、在 Scala 中，还可以声明抽象字段，甚至是抽象类型（types）作为一个类或是特质的成员

在 Scala 中，有四类成员的抽象，vals, vars, methods 和 types，如下所示：

trait Abstract {
  type T
  def transform(x: T): T
  val initial: T
  var current: T
}

使用type关键字来声明一个抽象类型，该类型没有指定确切的定义

在 Scala 中，抽象类和特质都不被称为抽象类型。抽象类型总是作为抽象类或特质的成员存在，而抽象成员在具体类（Concrete）中，作为别名的形式存在

抽象类型的两个用途：
1.为冗长的类名提供简化的方式
2.声明的抽象类型要求在子类中被定义

抽象不变值（vals）

抽象不变值（abstract val）约束着它的逻辑实现：只能由不变值（val）来进行定义，不能由 var 或是 def 来进行定义

抽象方法（无参）却可以由 def 或 val 进行定义

抽象不变值的初始化

对于不变值初始化的理解，需要记住的是，作为类参数，是在类初始化之前被求值；作为特质的抽象不变值，按照正常的匿名类的初始化方式，是在特质初始化之后被求值，这就可能导致相关的问题。应对的方案是预初始化（pre-initialized fields）和惰性求值（lazy vals）两种方式

trait RationalTrait {
  val numerArg: Int
  val denomArg: Int 
}

class Rational(numer: Int, denom: Int)

// 在 RationalTrait 初始化完成之后 expr1，expr2 进行求值
new RationalTrait {
  val numerArg = expr1
  val denomArg = expr2
}

// 在 Ratinal 初始化之前 expr1，expr2 被求值
new Rational(expr1, expr2)

鉴于特质中抽象不变值的初始化顺序可能造成的问题，使用预初始化来精准控制初始化顺序，或者惰性求值来进行延时处理字段的初始化

// 预初始化
new {
  val numerArg = expr1
  val denomArg = expr2
} with RationalTrait

// 惰性求值
trait RatinalTrait {
  lazy val numerArg: Int
  lazy val denomArg: Int
}

new RationalTrait {
  val numerArg = expr1
  val denomArg = expr2
}

抽象可变值（vars）

抽象可变值有着特别的地方。如果在类中定义一个 var 成员，编译器会自动给该成员加上 getter 和 setter 方法。那么声明一个抽象的 var，编译器也会隐式地给该成员添加 getter 和 setter，但是没有可赋值的字段被定义，如下所示：

trait Foo {
  var bar: String
}

// 和下面的代码是等效的

trait Foo {
  def bar: String
  def bar_=(x: String)
}

抽象可变值可以在子类中使用 var 或是 def 进行定义，但是有些地方需要注意

trait Foo {
  var bar: String
}

// 使用 var 进行定义
class ConcreteFoo extends Foo {
    override var bar: String = "hello"
}

// 使用 def 进行定义
class ConcreteFoo extends Foo {
    override def bar: String = "hello"
    override def bar_=(x: String) = x
}

上述代码示例中，可以编译通过，但是bar_=方法却没有实际的意义，因为没有一个可赋值字段来承载 x 的值

抽象类型（Abstract Types）

抽象类型的声明是某种需要在子类中进行具体化的占位符，也就是说具体的定义落到继承体系的底层

通常抽象类型的使用会配合上界的约束来进行，如下所示：

class Food
abstract class Animal {
  type SuitableFood <: Food
  def eat(food: SuitableFood)
}

路径依赖类型（Path-dependent types）

路径依赖类型中的“路径”指的是一个对象的变量名称，如farm.barn.bessy，farm，barn，bessy都是对象的变量名称

通过名字可以理解，这个类型是依赖路径的，不同的路径给出不同的类型

和 Java 内部类的区别

1.路径依赖类型命名（names）外部对象，而内部类命名外部类名
2.在 Scala 中用Outer#Inner来表达，而 Java 用Outer.Inner

其他

1.路径依赖类型的实例持有一个外部对象的引用
2.不能直接使用new Outer#Inner来初始化路径依赖类型

改良类型（Refinement Types）

所谓的改良类型，就是结构化的子类型（structural subtyping），因为子类型之间含有相兼容的成员（compatible members），通过它能够得到一个简单的子类型关系

与结构子类型对应的就是名义子类型（Nominal subtyping），其通常更为方便，拥有简短的标识符，因此更为简单，而不像结构子类型显示的列出成员类型

可是结构子类型通常更为灵活（flexible），能够抽象出很多有趣的事情

// animal that eats grass
Animal { type SuitableFood = Grass }

class Pastrue {
  var animals: List[Animal { type SuitableFood = Grass}] = Nil
}

枚举

枚举在 Scala 中是路径依赖类型的应用案例

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

Color.Value 就是 Red，Green，Blue 的路径依赖类型