1

给定三个属于一起的类（我试图通过类型参数来表达这一点）：

abstract class Row[T <: Table[T, R, B], 
                   R <: Row[T, R, B], 
                   B <: RowBuffer[T, R, B]] extends Immutable {
  def id: Int
  def getTable: T
  def toRowBuffer: B

  def delete() {
    // does not compile: Found Row.this.type ... Row[T, R, B], required: R
    getTable.delete(this)
  }
}

abstract class RowBuffer[T <: Table[T, R, B], 
                         R <: Row[T, R, B], 
                         B <: RowBuffer[T, R, B]] extends Mutable {
  def id: Int
  def getTable: T
  def toRow: R

  def insert(): R = {
    // does not compile: Found RowBuffer.this.type ... RowBuffer[T, R, B], 
    // required: B
    getTable.insert(this)
  }
}

abstract class Table[T <: Table[T, R, B], 
                     R <: Row[T, R, B], 
                     B <: RowBuffer[T, R, B]] {
  def insert(b: B): R = {
    // insert ...
    b.toRow
  }

  def delete(r: R) {
    // delete ...
  }

如果有“跨类”调用，我还没有设法定义正确的类型。所以我的问题是：

  • 这个问题叫什么名字？
  • 如何以类型安全的方式表达它？
4

1 回答 1

3

我总是将此构造称为“表示”类型，但也许这不是正式名称（您可能会听到术语“F-bounded quantification”）。您的类型Row并RowBuffer采用递归类型R，并B分别描述最终实现的类型（“表示”）。

为了确保您可以填写抽象类的方法，您需要声明最终实现将分别符合R和B。您可以使用自类型注释来做到这一点：

abstract class Row[T <: Table[T, R, B], 
                   R <: Row[T, R, B], 
                   B <: RowBuffer[T, R, B]] extends Immutable {
  _: R =>

  ...
}

abstract class RowBuffer[T <: Table[T, R, B], 
                         R <: Row[T, R, B], 
                         B <: RowBuffer[T, R, B]] extends Mutable {
  _: B =>

  ..
}

请注意，您可以使用任何标识符，例如this: R =>或self: R =>。

有了这些，它就可以编译，你不能创建一个不满足约束的非抽象子类。

于 2013-06-20T09:20:28.747 回答