Question

我脑子里有以下课程：

abstract class MyClass (data: MyData) {

  def update(): MyClass = {
    new MyClass(process())
  }

  def process(): MyData = {
    ...
  }

}

但是，无法实例化抽象类，因此行new MyClass(process())是错误的。我的问题是 - 有没有办法告诉编译器，在MyClass的每个子类的情况下，我想创建一个完全该子类的对象？在所有子类中编写此方法awhole似乎有点过分。使用类或方法的类型参数，我无法实现自己。

Answer 1

这样的事情怎么样？ MyClass使用具体类型进行参数化。当然，所有具体类都必须实现一个实际返回Self的新实例的方法。

trait MyClass[+Self <: MyClass[Self]] {
  def update(): Self = {
    makeNew(process())
  }

  def process(): MyData = {
    // ...
  }

  protected def makeNew(data: MyData): Self
}

class Concrete0 extends MyClass[Concrete0] {
  protected def makeNew(data: MyData) = new Concrete0
}

class RefinedConcrete0 extends Concrete0 with MyClass[RefinedConcrete0] {
  override protected def makeNew(data: MyData) = new RefinedConcrete0
}

信用：IttayD’s second update to his answer至this question。

Answer 2

要完全避免在所有子类中实现几乎相同的方法，您需要使用反射。如果您选择Scala，我想这将是您最后的选择。所以这里是如何最小化重复代码：

// additional parameter: a factory function
abstract class MyClass(data: MyData, makeNew: MyData => MyClass) {

  def update(): MyClass = {
    makeNew(process())
  }
  def process(): MyData = {
    ...
  }
}

class Concrete(data: MyData) extends MyClass(data, new Concrete(_))

这样，您只重复实例化子类所需的最短片段。

Scala抽象类方法，返回一个新的相应类子对象

2 个答案: