Rasgos de Scala

DataCamp ha lanzado recientemente su primer curso en Scala: Introducción a Scala. ¡Compruebalo!

También podría estar interesado en leer los siguientes tutoriales:

• Guía para principiantes de Scala
• IF ELSE en Scala
• Operadores en Scala
• Listas en Scala
• Clases y objetos en Scala

Introducción

Un Trait es un concepto predominantemente utilizado en programación orientada a objetos, que puede ampliar la funcionalidad de una clase mediante un conjunto de métodos.

Traits son similares en espíritu a interfaces en el lenguaje de programación Java. A diferencia de una clase, los traits de Scala no pueden ser instanciados y no tienen argumentos o parámetros. Sin embargo, puedes heredar (extender)los mismos usando clases y objetos. Dicho esto, los traits proporcionan un conjunto específico de métodos/funciones que ejecutan un comportamiento en una clase y esperan que la clase implemente un conjunto de métodos que luego parametrizan el comportamiento proporcionado.

Un trait que se utiliza para definir un objeto se crea como una mezcla de métodos que pueden ser usados por diferentes clases sin requerir la herencia múltiple. Sin embargo, pueden existir casos atípicos en los que dos traits tienen un método con el mismo nombre (colisión de nombres), que deben ser usados por una clase, en cuyo caso la ambigüedad debe ser resuelta explícitamente.

Los traits pueden tener tanto abstractos como no abstractos métodos, campos como sus miembros. Cuando no inicies un método en un trait, entonces son abstractos, mientras que los que se inicializan se denominan no abstractos. En los métodos abstractos, la clase que implementa el trait se encarga de la inicialización.

Ahora, vamos a entender rápidamente los traits de Scala con ayuda de algunos ejemplos!

Sintaxis de Trait en Scala

La sintaxis para un trait de Scala es sencilla, se define con la palabra clave trait seguida del nombre del trait.

trait Trait_Name{
// Variables
// Métodos
}

Como puede ver de la definición de rasgo anterior, se define unatraza llamada DataCamp, que no tiene variables ni métodos definidos dentro de ella.

Vamos a pasar a un ejemplo simple de trazas en Scala, que le dará mucha más claridad sobre cómo funcionan programáticamente.

Como se discutió en la introducción, las trazas en Scala son heredadas por una clase usando la palabra clave extends.

class Scala_Tutorial extends DataCamp{
// Variables
// Métodos
}

Vamos a definir una traza llamada Scala_Course, que será heredada por la clase DataCamp. Dentro de la trait, definirás un método abstracto llamado scala(), que será definido en la clase DataCamp.

trait Scala_Course{  
    def scala()  
}  

class DataCamp extends Scala_Course{  
    def scala(){  
        println("DataCamp has recently launched there first Scala course")  
    }  
}  

object Main{  
    def main(args:Array[String]){  
        var a = new DataCamp()  
        a.scala()  
    }  
}

Ahora ejecute el código de arriba.

En el ejemplo anterior, el método scala() era un método abstracto, por lo tanto, su declaración se hizo en la clase que heredó esa traza.

Pero ¿qué pasa si tienes un método (no abstracto) que ya está implementado en la traza? Bien, en ese caso, la clase que extiende esta traza no necesita implementar el método que ya está implementado en una traza.

Vamos a entender esto con la ayuda de un pequeño ejemplo.

trait BMW{

    // trabajo con variables de rasgo
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // método de rasgo: NO ABSTRACTO
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}


class Car extends BMW{
    // variables de clase
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

    // método de clase
    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }
}

object Main  
{

    // método principal
    def main(args: Array[String])  
    {

        // objeto de clase
        var obj = new Car();
        println("Calling the Class Method")
        obj.Merc_Specs();
        println("Calling the Trait Method")
        obj.Display();
    }
}

Vamos a ejecutar el código de arriba:

Ahora que has entendido la diferencia entre abstracto y no abstracto métodos, veamos qué puede salir mal cuando un método abstracto no se implementa en la clase que hereda o extiende de él.

Usaremos el mismo ejemplo para entender este concepto.

trait Scala_Course{  
    def scala()  
}  

class DataCamp extends Scala_Course{  
    def print(){  
        println("Error: Class DataCamp needs to be Abstract")  
    }  
}  

object Main{  
    def main(args:Array[String]){  
        var a = new DataCamp()  
        a.print()  
    }  
}

La ejecución del código de arriba resulta en un error, como se muestra a continuación, ya que no has definido el método de rasgo scala() (abstracto) en la clase que lo heredó.

Para que el código de arriba funcione, podría haber dos soluciones posibles:

• Defina el método scala() en la clase DataCamp o
• Defina a la clase DataCamp como abstracta.

El último tema para la sesión de tutorial de hoy es cómo puedes heredar múltiples rasgos en una sola clase. Así que, vamos a terminar rápidamente.

trait A{
// métodos
}
trait B{
// métodos
}
class C extends A with B{
}

trait BMW{


    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40
}

trait Merc{


    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50


}



class Car extends BMW with Merc{

    def BMW_Specs()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }


    def Merc_Specs()
    {
        println("Make of the Car : " + make1);
        println("Model of the Car : " + model1);
        println("Fuel capacity of the Car : " + fuel1);
    }

}


object Main  
{

    // método principal
    def main(args: Array[String])  
    {

        // objeto de clase
        var obj = new Car();
        println("Calling the BMW Trait")
        obj.BMW_Specs();
        println();
        println("Calling the Merc Trait")
        obj.Merc_Specs();
    }
}

Por último, ejecutemos el código anterior.

¡Felicitaciones!

Felicitaciones por finalizar este tutorial.

Ahora sabes qué son los Traits en programación y cómo utilizarlos en Scala. Un buen ejercicio para ti sería buscar una solución para el método abstracto que no está definido en la clase que lo hereda. Trata de escribir código para lo mismo y ve si el código se ejecuta sin ningún error de compilación. Un pequeño consejo, quizás quieras consultar las Clases Abstractas en Scala.

Por favor, no dude en preguntar cualquier duda relacionada con este tutorial en la sección de comentarios de abajo.

Por último, no olvides tomar el nuevo curso de Scala en DataCamp, Introducción a Scala.