Question

假设您有一个具有自我类型的特征，并且您已经覆盖了其中一个方法：

trait A {
  def foo() { println("A") }
}

trait B { this: A =>
  override def foo() {
    println("B")
  }
}

object Test {
  def main (args: Array[String]) {
    val b = new A with B {}
    b.foo()
  }
}

到目前为止一直很好，它编译并产生“B”到输出。但是如何从A调用“阴影”方法来执行以下操作：

trait A {
  def foo() { println("Hello, ") }
}

trait B { this: A =>
  override def foo() {
    //here I'd like to do something like super.foo()
    println("world!")
  }
}

object Test {
  def main (args: Array[String]) {
    val b = new A with B {}
    b.foo() //Should print "Hello, world!"
  }
}

甚至可以调用覆盖foo吗？或者我应该更喜欢继承自我类型来实现这一目标吗？

Answer 1

您正在寻找的是抽象覆盖，它允许您实现可堆叠的特征模式。

如果您在特质A上定义foo，例如以下

trait A {
  def foo()
}

trait M extends A {
  abstract override def foo() {println("M"); super.foo()}
}

class FooImpl1 extends A {
  override def foo() {println("Impl")}
}

class FooImpl2 extends FooImpl1 with M

Answer 2

受Edmondo版本的启发：

scala> class C { def c = "C" }
defined class C

scala> trait T1 { def c:String }
defined trait T1

scala> trait T2 extends T1 { self:C => 
     | abstract override def c = super.c + " with T2" 
     |}
defined trait T2

scala> new C with T2
res0: C with T2 = $anon$1@1f841222

scala> res0.c
res1: java.lang.String = C with T2

从具有自我类型的特征调用重写方法

2 个答案: