Scala Traits

DataCamp lançou recentemente seu primeiro curso de Scala: Introdução a Scala. Confira!

Você pode também estar interessado em ler os seguintes tutoriais:

• Guia de Iniciantes em Scala
• IF ELSE em Scala
• Operadores em Scala
• Listas em Scala
• Classes e Objetos em Scala

Introdução

Um Trait é um conceito predominantemente usado na programação orientada a objetos, o qual pode estender a funcionalidade de uma classe usando um conjunto de métodos.

Traits são semelhantes em espírito a interfaces na linguagem de programação Java. Ao contrário de uma classe, traits em Scala não podem ser instanciadas e não têm argumentos ou parâmetros. No entanto, você pode herdá-las (estender) usando classes e objetos. Dito isto, traits fornecem um conjunto específico de métodos/funções que executam um comportamento em uma classe e esperam que a classe implemente um conjunto de métodos que então parametrizam o comportamento fornecido.

Uma trait usada para definir um objeto é criada como uma mistura de métodos que podem ser usados por diferentes classes sem exigir herança múltipla. No entanto, podem existir exceções em que duas traits têm um método com o mesmo nome (colisão de nomes), que têm de ser usados por uma classe, caso em que a ambiguidade tem de ser resolvida explicitamente.

Traits podem ter ambos abstratos e não-abstratos métodos, campos como seus membros. Quando você não inicializa um método em uma trait, então eles são abstratos, enquanto aqueles que são inicializados são chamados de não-abstratos. Nos métodos abstratos, a classe que implementa a trait cuida da inicialização.

Agora, vamos compreender rapidamente traits em Scala com a ajuda de alguns exemplos!

Sintaxe de Trait em Scala

A sintaxe para uma trait em Scala é direta, é definida pela palavra-chave trait seguida pelo nome da trait.

trait Trait_Name{
// Variáveis
// Métodos
}

Como podem ver da definição de traço acima, um traço chamado DataCamp foi definido, que não tem nenhuma variável e método definidos dentro dele.

Vamos passar para um exemplo simples de traços em Scala, que nos dá muito mais clareza sobre como eles funcionam programaticamente.

Como discutido na introdução, os Traços em Scala são herdados por uma classe usando a palavra-chave extends.

class Scala_Tutorial extends DataCamp{
// Variáveis
// Métodos
}

Vamos definir um traço chamado Scala_Course, que será herdado pela classe DataCamp. Dentro do trait, você vai definir um método abstrato chamado scala(), que será definido na classe 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()  
    }  
}

Agora vamos executar o código acima.

No exemplo acima, o método scala() era um método abstrato, portanto, a declaração foi feita na classe que herdou esse traço.

Mas e se você tiver um método (não abstrato) que já está implementado no traço? Bem, nesse caso, a classe que extende esse traço não precisa implementar o método que já está implementado em um traço.

Vamos entender isso com a ajuda de um exemplo pequeno.

trait BMW{

    // variáveis de trait
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // método de trait: NÃO-ABSTRATO
    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{
    // variáveis de classe
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

    // Método de classe
    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 classe
        var obj = new Car();
        println("Calling the Class Method")
        obj.Merc_Specs();
        println("Calling the Trait Method")
        obj.Display();
    }
}

Vamos executar o código acima:

Agora que você entendeu a diferença entre os métodos abstract e non-abstract, vamos ver o que pode dar errado quando um método abstract não é implementado na classe que o herda ou estende.

Vamos usar o mesmo exemplo para entender esse conceito.

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()  
    }  
}

A execução do código acima resulta em um erro, conforme mostrado abaixo, pois você não definiu o método do trait scala() (abstrato) na classe que o herdou.

Para fazer o código acima funcionar, poderiam existir duas soluções possíveis:

• Definir o método scala() na classe DataCamp ou
• Definir a classe DataCamp como abstract.

O último tópico para o tutorial de hoje é como você pode herdar vários traits em uma única classe. Então, vamos terminar rapidamente.

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 classe
        var obj = new Car();
        println("Calling the BMW Trait")
        obj.BMW_Specs();
        println();
        println("Calling the Merc Trait")
        obj.Merc_Specs();
    }
}

Finalmente, executemos o código acima.

Parabéns!

Parabéns por concluir este tutorial.

Agora você sabe o que são Traits em programação e como usá-los em Scala. Um bom exercício para você seria encontrar uma solução para o método abstrato quando não definido na classe que o herda. Tente escrever o código para isso e veja se o código executa sem nenhum erro de compilação. Um pequeno conselho, você pode querer olhar para as classes abstratas em Scala.

Por favor, não se sinta impedido de fazer qualquer pergunta relacionada a este tutorial nos comentários abaixo.

Finalmente, não esqueça de pegar o novo curso de Scala em DataCamp, Introduction to Scala.