實現具有特徵的不一致編譯器行爲的抽象方法？

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。