Question

假设我有一个名为A的班级：

class A(i: Int) {
  //private def to initialize a calculated value
  def maintainedValue : Int = calculatedValue

  def double : A = new A(maintainedValue * 2)
  def combine(other: A) : A = new A(maintainedValue + other.maintainedValue)
  def addAmt(amt : Int) : A = new A(maintainedValue  + amt)
  // Many many more methods
}

我想定义一个扩展类B的类A，以使它的方法几乎都具有相似的逻辑，并返回类B的对象：

class B(i: Int) extends A(i) {
  //private def to initialize a differently calculated value
  def maintainedValue : Int = diffCalculatedValue

  //Change all other methods to return type B without override???
}

是否可以在不覆盖所有方法的情况下做到这一点？

有没有简单的方法可以使用变量/动态类实例化这些新实例？

也许有更优雅的方法可以做到这一点？

Answer 1

具有通用逻辑和两个实现的基本特征如何？

object App extends App {
  println(A(1).double)
  println(B(1).double)
}


trait A {
  type TYPE

  def create(i: Int): TYPE

  def maintainedValue: Int

  def double: TYPE = create(maintainedValue * 2)

  def addAmt(amt: Int): TYPE = create(maintainedValue + amt)
}

trait B extends A {
}

object A {

  def apply(i: Int) = new AImpl(i)

  case class AImpl(i: Int) extends A {
    override type TYPE = A

    override def create(i: Int) = A(i)

    override def maintainedValue: Int = 2
  }

}

object B {

  def apply(i: Int): B = new BImpl(i)

  case class BImpl(i: Int) extends B {

    override type TYPE = B

    override def create(i: Int): TYPE = B(i)

    override def maintainedValue: Int = 1
  }

}

Answer 2

一种解决方案，也是我认为最简单的解决方案，是将类A更改为一种结构，以使单个方法可以处理对象的创建：

def create(i: Int): TYPE = new B(i)

在调用未更改的方法时，只需在类B中使用隐式方法即可处理转换：

private implicit def convert(a: A): B = new B(a.maintainedValue)

又矮又甜，尽管我很好奇这种解决方案的效率和/或可扩展性。

没有覆盖的Scala子类更改返回类型

2 个答案: