Scala泛型方法重写

Question

我有一个抽象类：

abstract class Foo(...){
   def bar1(f : Foo) : Boolean
   def bar2(f : Foo) : Foo
}

多个类扩展 Foo 并重写方法

class FooImpl(...) extends Foo{
    override def bar1(f : Foo) : Boolean {
        ...
    }
    override def bar2(f : Foo) : Foo {
        ...
    }
} 

是否可以使用泛型（或其他东西）使重写方法具有实现它的子类的参数类型？像这样：

class FooImpl(...) extends Foo{
    override def bar1(f : FooImpl) : Boolean {
        ...
    }
    override def bar2(f : FooImpl) : FooImpl {
        ...
    }
}

我正在思考以下内容，但这似乎不起作用......

abstract class Foo(...){
    def bar1[T <: Foo](f : T) : Boolean
    def bar2[T <: Foo](f : T) : T
}

class FooImpl(...) extends Foo{
    override def bar1[FooImpl](f : FooImpl) : Boolean {
       ...
    }
    override def bar2[FooImpl](f : FooImpl) : FooImpl{
       ...
    }
}

非常感谢任何帮助！

谢谢。

Answer 1

abstract class Foo{
   type T <: Foo
   def bar1(f:T):Boolean
   def bar2(f:T):T
}

class FooImpl extends Foo{
   type T = FooImpl
   override def bar1(f:FooImpl) = true
   override def bar2(f:FooImpl) = f
}

在此版本中，Foo 的不同子类都共享 Foo 作为超类，但保存 bar2 的返回值（或 Foo 的参数） code>bar1 或 bar2），在这样的设置中，您对对象（假设它名为 obj）的所有了解就是它是一个 Foo< /code>，您需要使用obj.T类型作为变量的类型。

Answer 2

为了让 Ken Blum 的第二个版本更好一点，你可以使用 self 类型：

abstract class Foo[T] { self:T =>
   def bar1(f:T):Boolean
   def bar2(f:T):T
}

class FooImpl extends Foo[FooImpl]{
   override def bar1(f:FooImpl) = true
   override def bar2(f:FooImpl) = f
}

Answer 3

T 需要是您继承的 Foo 类上的类型参数，而不是方法本身的类型参数。

abstract class Foo[T <: Foo[T]]{
   def bar1(f:T):Boolean
   def bar2(f:T):T
}

class FooImpl extends Foo[FooImpl]{
   override def bar1(f:FooImpl) = true
   override def bar2(f:FooImpl) = f
}

在此版本的代码中，Foo 的不同子类实际上没有共同的超类型，因为它们是从 Foo 的不同参数化扩展而来的。当您需要使用常见的超类型时，您可以使用引用 Foo[T] 的参数化方法，但我倾向于更喜欢我在其他答案中发布的抽象类型解决方案，因为它不将泛型的详细信息泄漏给必须处理 Foos 的所有其他函数。

Answer 4

理想情况下，您可以结合上面提到的内容，即

trait Foo[T <: Foo[T]] { self:T =>

“[T <: Foo[T]]”意味着 T 是 Foo[T] 的子类，
和“自我：T =>”意味着 Foo[T] 是 T 的子类，并且用一种有点奇怪的方式来告诉 Foo[T] 与 T 完全相同。

只有这样，我才能使以下代码编译并按预期工作：

trait Field[T <: Field[T]] { self:T =>

  def x2:T

  def +(that:T):T

  def *(n:BigInt) : T = {
    if(n == 1)
      this
    else if(n == 2)
      this.x2
    else if(n == 3)
      this + this.x2
    else {
      val p = (this * (n/2)).x2
      if (n%2==0)
        p
      else
        p + this
    }        
  }

}

Answer 5

您可以参数化 Foo 来轻松实现某些效果：

abstract class Foo[F <: Foo[F]] { def f: F }
class Food extends Foo[Food] { def f = this }  // Yay!
class Fool extends Foo[Food] { def f = new Food }  // Uh-oh...

如果您想排除第二种情况，则使用 Scala 中的当前功能没有直接的方法可以做到这一点。

另外，如果您在 Foo 中给出实际的实现，那么您似乎想要的一些内容就没有意义。如果 Foo 承诺接受任何 Foo 但你给它一个坚持只需要 Food 的方法，那么如果你向它传递一个Foo 的不同子类（例如 Fool）。所以编译器不会让你这样做。

abstract class Foo { def bar(f: Foo) : Foo }
class Foot extends Foo { def bar(f: Foo) = this }   // Fine!
class Fool extends Foo { def bar(f: Fool) = this }   // No good!