1

假设，您有一个带有 selftype 的特征，并且您已经覆盖了其中一种方法：

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!"
  }
}

甚至可以调用 overridenfoo吗？或者我应该更喜欢继承而不是 selftype 来实现这一点？

4

2 回答 2

4

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

如果您在特征 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
于 2012-07-26T12:01:04.293 回答
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
于 2012-07-26T13:34:27.703 回答