Question

我有一个抽象类，其方法将List of Floats作为参数：

abstract class a {
    def m(p: List[Float]) {
        println("Passed List[Float] to p()")
    }
}

我想在具体的扩展类中重载m：

class b extends a {
    def m(p: List[Double]) {
        println("Passed List[Double] to p()")
    }
}

有没有办法实现这个目标？当我尝试它时，我得到了这个错误：

error: name clash between defined and inherited member:
method m:(p: List[Double])Unit and
method m:(p: List[Float])Unit in class a
have same type after erasure: (p: List)Unit
   def m(p: List[Double]) {

Answer 1

有一个override关键字，但在这种情况下问题是编译时的TypeErasure。第一种方法需要List[Float]，另一种方法需要List[Double]。

这些类型将被删除，因此您将获得两种方法，即List并返回Unit。这就是冲突。

更改名称

现在简单的解决方案是给他们不同的名字。

使用泛型

abstract class a[T] {
    def m(p: List[T]) {
        println("Passed List[Float] to p()")
    }
}

class b extends a[Double] {
}

Answer 2

您必须以某种方式更改签名，因此您需要一个伪参数。

abstract class A {
  def m(p: List[Float]) { println(p.sum) }
}

class B extends A {
  def m(p: List[Double])(implicit dummy: Unit = ()) { println(p.product) }
}

现在

scala> val b = new B
b: B = B@6275a43c

scala> { b.m(List(3.0f,3.0f)); b.m(List(3.0, 3.0)) }
6.0
9.0

耶！

另一方面，这实际上可以使事情变得不那么方便。

scala> val a = new A {}
a: A = $anon$1@1283bbd2

scala> a.m(List(3,3))
6.0

scala> b.m(List(3,3))
<console>:11: error: overloaded method value m with alternatives:
  (p: List[Double])(implicit dummy: Unit)Unit <and>
  (p: List[Float])Unit
 cannot be applied to (List[Int])
              b.m(List(3,3))
                ^

并不是说你知道哪一个是正确的，b。所以这有助于保护您免受错误的影响，但代价是不能推断出正确的类型（因为这是正确的类型）。

Answer 3

我不确定你到底想要做什么，但我还有另一个建议

abstract class A {
  protected def _m(p: List[Float]) {
  }
}

class B extends A {
  def m(p: List[Double]){
    _m(p.map(_.toFloat))
  }
}

class C extends A {
  def m(p: List[Float]) {
    println("Passed List[Float] to p()")
    _m(p)
  }
}

如何覆盖超类方法

3 个答案: