¿Cuál es la diferencia entre mixins estáticas y rasgo dinámico

Question

Considerando:

abstract class Base { 
    def something() = println("Base") 
} 

trait TraitA extends Base { 
    abstract override def something() = { super.something(); println("TraitA"); } 
} 

class Child extends Base { 
    override def something() { 
     println("Child") 
    } 
} 

Y luego:

val x = new Child with TraitA 
x.something() 

me sale:

Child 
TraitA 

Pero si uso:

class Child extends Base with TraitA { 
    override def something() { 
     println("Child") 
    } 
} 

val x = new Child 
x.something() 

que conseguiría solamente:

Child 

¿Cuáles son los differentes de la utilización de un rasgo en el sitio de construcción o sitio de declaración? ¿Puedo tener el primer comportamiento (rasgos apilables) mientras extiendo/con el rasgo en la declaración de la clase?

Answer 1

Rasgos apilables en Scala se refiere a poder mezclar en múltiples rasgos que trabajan juntos para aplicar múltiples modificaciones a un método. Esto implica invocar super.theMethod y modificar su entrada y/o salida. Pero, ¿qué es súper en el contexto de un rasgo? La clase (o el rasgo ) del rasgo se extiende desde? La clase en la que se está mezclando el rasgo es? ¡Depende! Todos los rasgos mixtos y todas las superclases son linealizados. super invoca la definición precedente más cercana más arriba la cadena.

read full post

En su caso: 1.
super.something() == Child.something()
2. super.something() == Base.something() y el Niño. algo() anula toda la cadena

Tipo de mixin no importa:

class Child2 extends Child with TraitA 

val x2 = new Child2 
x2.something() 
/* 
    Child 
    TraitA 
*/ 

class Child3 extends Base with TraitA 
val x3 = new Child3 
x3.something() 
/* 
    Base 
    TraitA 
*/ 

Answer 2

En el primer ejemplo, anula primero el método de Base y luego mezcla TraitA que se apilará.

En el segundo ejemplo, primero mezcle TraitA y luego anule el método resultante (apilado).