Escala | Rasgos

Los rasgos son como interfaces en Java . Pero son más potentes que la interfaz en Java porque en las características se le permite implementar los miembros. Los rasgos pueden tener métodos (tanto abstractos como no abstractos) y campos como sus miembros.

• Los rasgos se crean utilizando palabras clave de rasgos .
  Sintaxis:

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

  Ejemplo:

  // Scala program to illustrate how to  // create traits    // Trait  trait MyTrait {     def pet      def pet_color }    // MyClass inherits trait class MyClass extends MyTrait {            // Implementation of methods of MyTrait     def pet()     {         println("Pet: Dog")     }            def pet_color()     {         println("Pet_color: White")     }            // Class method     def pet_name()     {         println("Pet_name: Dollar")     } }     object Main  {            // Main method     def main(args: Array[String])      {         val obj = new MyClass();         obj.pet();         obj.pet_color();         obj.pet_name();     } }

  Producción:

  Pet: Dog
  Pet_color: White
  Pet_name: Dollar
  

• En Scala, podemos implementar el método (solo métodos abstractos) en rasgos. Si un rasgo contiene la implementación de un método, entonces la clase que extiende este rasgo no necesita implementar el método que ya implementó en un rasgo. Como se muestra en el siguiente ejemplo.
  Ejemplo:

  // Scala program to illustrate the concept of // abstract and non-abstract method in Traits    // Trait with abstract and non-abstract methods trait MyTrait {     // Abstract method      def greeting        // Non-abstract method     def tutorial     {         println("This is a tutorial" +                  "of Traits in Scala")     } }       // MyClass inherits trait class MyClass extends MyTrait {            // Implementation of abstract method     // No need to implement a non-abstract      // method because it already implemented     def greeting()     {         println("Welcome to GeeksfoGeeks")     } }     object Main {            // Main method     def main(args: Array[String])      {         val obj = new MyClass();         obj.greeting         obj.tutorial     } }

  Producción:

  Welcome to GeeksfoGeeks
  This is a tutorial of Traits in Scala
  

• Traits no contiene parámetros de constructor.
• Cuando una clase hereda un rasgo, use la palabra clave extends .
  Sintaxis:

  class Class_Name extends Trait_Name{
  // Code..
  }

• Cuando una clase hereda múltiples rasgos, use la palabra clave extend antes del primer rasgo y luego use la palabra clave with antes de otros rasgos. Como se muestra en el siguiente ejemplo.
  Sintaxis:

  class Class_Name extends Trait_Name1 with Trait_Name2 with Trait_Name3{
  // Code..
  }

  Ejemplo:

  // Scala program to illustrate how // a class inherits multiple traits    // Trait 1 trait MyTrait1 {            // Abstract method      def greeting    }    //Trait 2 trait MyTrait2 {            // Non-abstract method     def tutorial     {         println("This is a tutorial" +                 "of Traits in Scala")     } }    // MyClass inherits multiple traits class MyClass extends MyTrait1 with MyTrait2 {            // Implementation of abstract method     def greeting()     {         println("Welcome to GeeksfoGeeks")     } }     object Main  {            // Main method     def main(args: Array[String])      {         val obj = new MyClass();         obj.greeting         obj.tutorial     } }

  Producción:

  Welcome to GeeksfoGeeks
  This is a tutorial of Traits in Scala
  

• Una clase abstracta también puede heredar rasgos usando la palabra clave extends .
  Sintaxis:

  abstract class Class_name extends Trait_Name{
  // code..
  }

• En Scala, un rasgo puede heredar otro rasgo usando una palabra clave extendida .
  Sintaxis:

  trait Trait_Name1 extends Trait_Name2{
  // Code..
  }

• Los rasgos admiten la herencia múltiple.
• En Scala, una clase puede heredar tanto clases normales como clases abstractas y rasgos usando la palabra clave extends antes del nombre de la clase y con la palabra clave antes del nombre del rasgo.
  Sintaxis:

  class Class_Name1 extends Class_Name2 with Trait_Name{
  // Code..
  } 

• En Traits, los campos abstractos son aquellos campos que contienen un valor inicial y los campos concretos son aquellos campos que contienen el valor inicial. se nos permite anularlos en la clase que extiende el rasgo. Si un campo se declara usando la palabra clave var , entonces no hay necesidad de escribir la palabra clave de anulación cuando las anulamos. Y si un campo se declara usando la palabra clave val , entonces debe escribir la palabra clave de anulación cuando las anulemos.
  Ejemplo:

  // Scala program to illustrate  // concrete and abstract fields in traits    trait MyTrait {            // Abstract field     var value: Int             // Concrete field     var Height = 10     val Width = 30 }    class MyClass extends MyTrait {            // Overriding MyTrait's fields     var value = 12     Height = 40     override val Width = 10            // Method to display the fields     def Display()     {         printf("Value:%d", value);         printf("\nHeight:%d" ,Height);         printf("\nWidth:%d", Width);     } }    object Main {            // Main method     def main(args: Array[String])     {         val obj = new MyClass();         obj.Display();     } }

  Producción:

  Value:12
  Height:40
  Width:10

• También podemos agregar rasgos a una instancia de objeto. O, en otras palabras, podemos agregar directamente un rasgo en el objeto de una clase sin heredar ese rasgo en la clase. Podemos agregar un rasgo en la instancia del objeto usando la palabra clave with .
  Sintaxis:

  val object_name = new Class_name with Trait_Name;

  Ejemplo:

  // Scala program to illustrate how  // to add a trait to an object instance     class MyClass{} trait MyTrait {     println("Welcome to MyTrait"); } object Main  {            // Main method     def main(args: Array[String])     {                    // Here MyTrait is added to the          // object instance of MyClass         val obj = new MyClass with MyTrait;     } }

  Producción:

  Welcome to MyTrait