¿Por qué una clase no puede extender rasgos con el método de la misma firma?

Question

¿Por qué es el error a continuación? ¿Cómo solucionarlo?

EDITAR: Asumí que como A y B se compilan para pares de (interfaz, clase), es una cuestión de elegir la llamada a método estático correcta para implementar al compilar C. Esperaría que la prioridad fuera según el orden.

 
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: tenga en cuenta que en Ruby esto funciona así:

 
>> 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

Esto funciona para mí en 2.8 y 2.11, y permitiría a ser no intrusiva en los rasgos 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

Se puede usar un rasgo de base común, por ejemplo Base, de la siguiente manera:

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 jerarquía de tipos del El resultado de llamar a hi es el siguiente (tenga en cuenta el uso de {} para crear instancias de los rasgos):

scala> (new A {}).hi 
A 

scala> (new B {}).hi 
B 

scala> (new C).hi 
B 

Answer 3

Este es el diamond problem. ¿Qué método hi se debe heredar, el de A o el de B? Puede evitar esto como sugirió Don, al usar un rasgo base común.

Answer 4

Un rasgo agrega métodos a la clase que lo mezcla. Si dos rasgos agregan el mismo método, la clase terminaría con dos métodos idénticos, que, por supuesto, no pueden suceder.

Si el método es privado en el rasgo, sin embargo, no causará ningún problema. Y si desea que los métodos se superpongan entre sí, puede definir un rasgo base y luego abstract override en los rasgos heredados. Sin embargo, requiere una clase para definir el método. Aquí es un ejemplo de esto:

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 

Sin embargo, si usted realmente quiere dos métodos separados de cada rasgo, entonces tendrá que componer en lugar de heredar .

Answer 5

que tenían el mismo problema y no me gustaba tener que crear un rasgo intermediario porque puedo tener 4,5 o incluso 6 rasgos con los mismos métodos, porque son rasgos que contienen operaciones CRUD (buscar, crear ...). Además, necesitaba usar esos rasgos juntos solo para fines de prueba y siempre trato de evitar tanto como sea posible modificar la estructura de mi proyecto solo para facilitar mi prueba. Así que simplemente implementar esos rasgos en diferentes objetos:

class somethingToTest { 
    object AImpl extends ATrait 
    object BImpl extends BTrait 

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

probablemente no es la forma más inteligente de utilizar rasgos pero no requiere ningún cambio en el código del proyecto, que sólo implica tener un poco más código en las pruebas.