实现具有特征的不一致编译器行为的抽象方法？

Question

我有一个来自Java库的基类，其代码无法修改。这个类（A）有一个空的方法（b）应已被定义为抽象的，而不是：

class A { 
    def b { } 
} 

我在斯卡拉这个类扩展和覆盖的方法，使其摘要：

abstract class AA extends A { 
    override def b 
} 

现在我实现的性状此方法：

trait B { 
    def b { println("B") } 
} 

如果我延伸与性状b AA，得到了一个错误：在类型=>单位的A类覆盖方法b;在型性状B 方法B =>单元需要'覆盖”修饰符：

class C extends AA with B {} 

相反，如果代码已经这个样子，一切都编译没有错误，这似乎有点矛盾对我说：

abstract class AA { 
    def b 
} 

trait B { 
    def b { println("B") } 
} 

class C extends AA with B {} 

我正在运行Scala 2.8.0RC3，并且完全是新的语言（3天）。另一个奇怪的和相关的行为是做b抽象当制动标签是没有必要的：

abstract class AA extends A { 
    def b 
} 

Answer 1

不知道这是正确的解决方案，但如果你的trait B延伸A（和覆盖b），那么一切编译罚款：

首先让我们来定义A和AA就像你在你的问题呈现出来：

C:\Users\VonC>scala 
Welcome to Scala version 2.8.0.RC5 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_18). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> class A { 
    | def b { println("A b") } 
    | } 
defined class A 

scala> new A 
res5: A = A@153bedc4 

scala> res5.b 
A b 

scala> abstract class AA extends A { 
    | override def b 
    | } 
defined class AA 

你做了什么：

scala> trait B { 
    | override def b { println("B b") } 
    | } 
<console>:6: error: method b overrides nothing 
     override def b { println("B b") } 
        ^

我试图与性状B（为了能够加入 'override'）：

scala> trait B extends A { 
    | override def b { println("B b") } 
    | } 
defined trait B 

所以现在：

scala> class C extends AA with B {} 
defined class C 

scala> new C 
res7: C = C@1497b7b1 

scala> res7.b 
B b 

右b覆盖方法被调用与C.b

---

至于你明显“不一致”，见Scala for Java Refugees Part 5: Traits and Types：

To start with, there’s that ever-annoying override keyword. I mentioned back in the article on basic OOP that any method which overrides a method in a superclass must be declared with the override modifier. At the time, I likened it to the language mandating the use of the @Override annotation, with its primary purpose being to enforce the good practice.

The real key to the power of traits is the way in which the compiler treats them in an inheriting class.
Traits are actually mixins, not true parent classes.
Any non-abstract trait members are actually included in the inheriting class, as in physically part of the class. Well, not physically, but you get the picture.
It’s as if the compiler performs a cut-and-paste with the non-abstract members and inserts them into the inheriting class. This means that there’s no ambiguity in the inheritance path, meaning no diamond problem.

所以没必要在你的第二个例子override关键字。

Answer 2

试试，看看发生了什么事情，我想这样的：

scala> class A{ 
    | def b{ } 
    | } 
defined class A 

scala> abstract class AA extends A{ 
    | override def b 
    | } 
defined class AA 

scala> class AAA extends AA{ 
    | def b = println("AAA") 
    | } 
<console>:8: error: overriding method b in class A of type => Unit; 
method b needs `override' modifier 
     def b = println("AAA") 
      ^

显然，问题的根源是抽象类不能从需求的“释放”在其超类方法抽象类的子类包含'override'修饰符。

Answer 3

问题很微妙。作为一个经验法则，您的类AA，其中延伸A，应该混合性状，也扩展A。

你做到：

class A { 
    def b { } 
} 

abstract class AA extends A { 
    override def b 
} 

trait B { 
    def b { println("B") } 
} 

因此，当你混合AA和乙方法b被定义了两次。一旦通过甲（不overrided因为在乙定义在AA替换超驰）和第二通过乙，编译器不能选择一个在另一个之上，因为在二者之间没有层级（等同命名但不相关）的方法。如果你愿意，可以这样想：编译器“混合”AA和B;如果他选择的方法从AA它将是抽象的，如果他从B（应该发生的事情）选择方法，因为它不是一个覆盖，你坚持两种方法b。

为了解决这个问题，你要确保两个方法override都是相同的方法，在这种情况下，编译器会理解你正在谈论SAME方法，并会优先考虑混合的最后一个特征。

现在，要覆盖的方法b在乙，该类也必须从甲继承。所以规范的做法是：

class A { 
    def b { } 
} 

abstract class AA extends A { 
    override def b 
} 

trait B extends A{ 
    def b { println("B") } 
} 

class C extends AA with B {} 

编译得很好。

现在，当你这样做：

abstract class AA { 
    def b 
} 

trait B { 
    def b { println("B") } 
} 

class C extends AA with B {} 

很显然，这两种方法都是相同的，所以编译器知道他从特征使用的方法。

其他解决方案包括：

1. 让乙覆盖AA
2. 让b在一个抽象的（但你不希望出现这种情况）

再次，问题非常微妙，但我希望我更清楚一点。为了得到更好的理解，请阅读Scala's Stackable Trait Pattern。