从基本抽象类构造子类

Question

我想在抽象类中定义一个构造函数来创建具体的子类。

abstract class A {
  type Impl <: A
  def construct() : Impl = {
    val res = new Impl() //compile error: class type required but A.this.Impl found
    // do more initialization with res
  }
}

class B extends A {type Impl = B}
class C extends A {type Impl = C}
//...
val b = new B
b.construct() // this should create a new instance of B

这里有什么问题吗？这有可能实现吗？ 编辑：澄清：我想抽象构造方法。我不想从子类或伴随对象中单独调用 new B 和 new C 。

Answer 1

如果要创建新实例，则需要显式调用构造函数。

abstract class A {

  def newInstance(): this.type;

  def construct() : this.type = {
    val res = newInstance()
  }
}

class B extends A {
  def newInstance() = new B()
}

Scala 在运行时擦除类型，因此无法知道创建类时 Impl 的含义。

Answer 2

您可以将构造函数放在伴生对象中，而不是放在抽象类中。像这样：

object A {
  def apply(i:Int):A = new B(...)
  def apply(s:String):A = new C(...)
}

现在，您可以通过调用 A(42) 或 A("foobar") 创建 A 的实例，例如。当然，字符串和整数参数只是示例。如果所有构造函数的参数具有相同的类型，则此重载将不起作用。在这种情况下，您可以轻松创建不同的方法并将它们称为 apply 以外的名称。

Answer 3

您可以使用反射来创建新实例。像这样的事情会起作用，但在我看来不值得这么麻烦。一方面，您只能检查运行时是否存在合适的构造函数。

def newInstance[T:ClassManifest]:T = {
  val klass = implicitly[ClassManifest[T]].erasure
  val constr = klass.getConstructors()(0)
  constr.newInstance().asInstanceOf[T]
}

abstract class A {
  def construct(implicit cm:ClassManifest[this.type]): this.type = {
    val res = newInstance[this.type]
    res
  }
}

class B extends A

Answer 4

看来这是不可能的。根据 Scala 书（作者：Oderski、Spoon、Venners），您无法创建抽象类型的实例。请参阅：抽象类型章节，货币案例研究。稍后可能会通过“虚拟类”来支持这一点。

Answer 5

我建议采用以下模式：

abstract class A($params) {
  // do common initialisation here
  def construct() : A

  def foo(...) = {
    ...
    val bar = construct()
    ...
  }
}

class B($moreparams) extends A($someparams) {
  // do special initialisation here
  def construct() = new B()
}

您现在拥有的所有冗余恰好是每个子类一行。我认为这是一个很小的代价：a）一个可行的解决方案，b）不使用反射（这基本上破坏了静态类型系统为您提供的所有保证）。

我仍然很好奇为什么你需要在 A 中构建construct。闻起来有鱼腥味。

Answer 6

按照我在 Monkey 回复中留下的评论。解决此问题的一种方法是使用 Curiously Recurring Template Pattern (CRTP) 和self types：

abstract class A[T <: A[T]] { this: T =>

  def newInstance(): T;

  def construct(): T = {
    val res = newInstance()
    res
  }

  def some(): T = this
}

class B extends A[B] {
  def newInstance() = new B()
}

也许有更好的解决方案，但这是迄今为止我发现的。