Perché una classe non può estendere tratti con il metodo della stessa firma?

Question

Perché l'errore è sotto? Come risolverlo?

EDIT: Ho assunto che dal momento che A e B compili alle coppie (di interfaccia, di classe), si tratta di scegliere la giusta chiamata al metodo statico da implementare durante la compilazione di C. Mi aspetto che la priorità sia secondo l'ordine.

 
scala> trait A {def hi = println("A")} 
defined trait A 

scala> trait B {def hi = println("B")} 
defined trait B 

scala> class C extends B with A 
:6: error: error overriding method hi in trait B of type => Unit; 
method hi in trait A of type => Unit needs `override' modifier 
     class C extends B with A 

scala> trait A {override def hi = println("A")} 
:4: error: method hi overrides nothing 
     trait A {override def hi = println("A")} 

EDIT: Si noti che in Ruby questo funziona bene:

 
>> module B; def hi; puts 'B'; end; end 
=> nil 
>> module A; def hi; puts 'A'; end; end 
=> nil 
>> class C; include A; include B; end 
=> C 
>> c = C.new 
=> # 
>> c.hi 
B 
=> nil 

Answer 1

questo funziona per me in 2.8 e 2.11, e permetterebbe di essere non intrusivo in tratti A o B:

trait A { def hi = println("A") } 
trait B { def hi = println("B") } 

class C extends A with B { 
    override def hi = super[B].hi 
    def howdy = super[A].hi // if you still want A#hi available 
} 

object App extends Application { 
    (new C).hi // prints "B" 
} 

Answer 2

Si potrebbe utilizzare un tratto di base comune, dire Base, come segue:

trait Base {def hi: Unit} 
trait A extends Base {override def hi = println("A")} 
trait B extends Base {override def hi = println("B")} 
class C extends A with B 

Con la gerarchia dei tipi del il risultato della chiamata di hi è il seguente (notare l'uso di {} per istanziare i tratti):

scala> (new A {}).hi 
A 

scala> (new B {}).hi 
B 

scala> (new C).hi 
B 

Answer 3

Questo è il diamond problem. Quale metodo hi dovrebbe essere ereditato, quello da A o quello da B? Puoi aggirare questo come suggerito da Don, usando un tratto base comune.

Answer 4

Un tratto aggiunge metodi alla classe che lo mescola. Se due tratti aggiungono lo stesso metodo, la classe finirebbe con due metodi identici, il che, ovviamente, non può avvenire.

Se il metodo è privato nel tratto, tuttavia, non causerà problemi. E se vuoi che i metodi si impilino uno sull'altro, puoi definire una caratteristica di base e poi abstract override sui tratti ereditari. Tuttavia, richiede una classe per definire il metodo. Ecco un esempio di questo:

scala> trait Hi { def hi: Unit } 
defined trait Hi 

scala> trait A extends Hi { abstract override def hi = { println("A"); super.hi } } 
defined trait A 

scala> trait B extends Hi { abstract override def hi = { println("B"); super.hi } } 
defined trait B 

scala> class NoHi extends Hi { def hi =() } 
defined class NoHi 

scala> class C extends NoHi with B with A 
defined class C 

scala> new C().hi 
A 
B 

Se, invece, si vuole veramente due metodi separati da ogni tratto, allora avrete bisogno di comporre invece di Eredita.

Answer 5

Ho avuto lo stesso problema e non mi piaceva avere per creare un tratto intermedio perché posso avere 4,5 o addirittura 6 tratti con gli stessi metodi, perché sono tratti che contengono operazioni CRUD (trova, crea ...). Inoltre avevo bisogno di usare quei tratti insieme solo per scopi di test e cerco sempre di evitare il più possibile di modificare la struttura del mio progetto solo per rendere più facile il mio test. Così ho semplicemente implementato quei tratti in diversi oggetti:

class somethingToTest { 
    object AImpl extends ATrait 
    object BImpl extends BTrait 

    val a = AImpl.methodDuplicated() 
    val b = BImpl.methodDuplicated() 
} 

non è probabilmente il modo più intelligente di utilizzare i tratti, ma non richiede alcun cambiamento nel codice del progetto, implica solo per avere un po 'di più codice nei test.