Rasgos como modificaciones apilables

Los rasgos son similares a las interfaces de Java. Las clases y los objetos pueden extender los rasgos, los rasgos heredados se crean usando la palabra clave trait . 

Sintaxis: 

trait Trait_Name {
// Fields..
// Methods..
}

palabra clave super: se usa siempre que una base y una subclase tienen métodos con el mismo nombre, por lo que para resolver la ambigüedad usamos la palabra clave super para llamar al método de la clase base. 

Modificación apilable con rasgos 

Antes de continuar, primero debemos entender qué es una modificación apilable con la ayuda de un ejemplo. Considere un cliente que paga para recargar su teléfono móvil para usar servicios móviles como llamadas de voz, Internet, etc. Estos servicios se pueden dividir en diferentes paquetes según el uso de un usuario en particular. Si queremos implementar este servicio estaríamos obligados a tener el nombre del paquete por el cual el cliente ha pagado un paquete en particular, digamos DataPack . Entonces podemos decir lo siguiente. 

new Recharge with DataPack

Suponiendo que tenemos un valor particular en nuestra clase de recarga que tiene la lista de servicios enumerados en un paquete determinado. ¿Qué pasa si el consumidor quiere Recargar a un paquete más, y no queremos tener un mecanismo que modifique explícitamente la lista de servicios para nosotros, pero debería suceder por defecto? Esto es como un comportamiento que se modifica a medida que agregamos diferentes paquetes. Este tipo de situación nos hace conocer el concepto de modificaciones apilables. Con el cliente agrega un nuevo paquete, la lista seguirá actualizándose.

new Recharge with DataPack with FullTalkTime

Scala soporta comportamiento un comportamiento

El siguiente ejemplo ilustra cómo se pueden apilar los rasgos.

Ejemplo 1: 

En este ejemplo, usamos rasgos para modificar métodos de una clase usando rasgos de forma apilable. Aquí, usamos la palabra clave super para invocar el método dot() en ambos rasgos. De esta manera, logramos una modificación apilable. En casos de modificación apilable, el orden de invocación del método está determinado por la regla de linealización. 

// Scala program to illustrate traits 
// in stackable fashion
  
// Defining class shape
class Shape
{
  def dot(shape : String) = println("Dotted : " + shape)
}
  
// Using trait keyword
// Using super keyword
trait Square extends Shape 
{
  override def dot(shape : String) = super.dot("Square-" + shape)
}
  
// Using trait keyword
// Using super keyword
trait Circle extends Shape 
{
  override def dot(shape : String) = super.dot("Circle-" + shape)
}
  
// Using trait keyword
// Using super keyword
trait Sharp extends Shape
{
  override def dot(shape : String) = super.dot("Sharp-" + shape)
}
  
// Defining main
object Shapes 
{
  def main(args: Array[String]) 
  {
    val shape1 = new Shape with Sharp with Square
    shape1.dot("Shape-1") 
  
    val shape2 = new Shape with Circle with Sharp
    shape2.dot("Shape-2") 
}
}

Producción: 

Dotted : Sharp-Square-Shape-1
Dotted : Circle-Sharp-Shape-2

Ejemplo 2: 

// Scala program to illustrate traits 
// in stackable fashion
  
// Defining class Ball
class Ball 
{
  def spin(ball : String) = println("Spinning : " + ball)
}
  
// Using trait keyword
// Using super keyword
trait Yellow extends Ball
{
  override def spin(ball : String) = super.spin("Yellow-" + ball)
}
  
// Using trait keyword
// Using super keyword
trait Blue extends Ball 
{
  override def spin(ball : String) = super.spin("Blue-" + ball)
}
  
// Using trait keyword
// Using super keyword
trait Shiny extends Ball 
{
  override def spin(ball : String) = super.spin("Shiny-" + ball)
}
  
// Defining main
object Balls
{
  def main(args: Array[String])
  {
    val ball1 = new Ball with Shiny with Yellow
    ball1.spin("Ball-1") 
  
    val ball2 = new Ball with Blue with Shiny
    ball2.spin("Ball-2") 
}
}

Producción: 

Spinning : Shiny-Yellow-Ball-1
Spinning: Blue-Shiny-Ball-2