Características do Scala

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

Você pode estar interessado em ler os seguintes tutoriais:

• Guia para Iniciantes no Scala
• IF ELSE no Scala
• Operadores no Scala
• Listas no Scala
• Classes e Objetos no Scala

Introdução

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

Traits são similares em espírito às interfaces na linguagem de programação Java. Ao contrário de uma classe, traits em Scala não podem ser instanciadas e não possuem 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 requerer herança múltipla. No entanto, pode haver 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 os 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 você pode ver na definição do trait acima, foi definido um trait chamado DataCamp, que não possui variáveis nem métodos definidos dentro dele.

Vamos passar para um exemplo simples de traits em Scala, que lhe dará muito mais clareza sobre como eles funcionam programaticamente.

Como discutido na introdução, os Traits 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 trait chamado Scala_Course, que será herdado pela classe DataCamp. Dentro do trait, você 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, e portanto, a declaração foi feita na classe que herdou aquele trait.

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

Vamos entender isso com a ajuda de um pequeno exemplo.

trait BMW{

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

    // método de traço: 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 abstrato e não-abstrato métodos, vamos ver o que pode acontecer quando um método abstrato não é implementado na classe que herda ou estende ele.

Vamos usar o mesmo exemplo para entender este 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, já que você não definiu o método de traço scala() (abstrato) na classe que o herdou.

Para tornar o código acima funcionar, poderia haver duas soluções possíveis:

• Defina o método scala() na classe DataCamp ou
• Defina a classe DataCamp como abstrata.

O último tópico para o tutorial de hoje é como você pode herdar vários traços em uma única classe. Então, vamos finalizar rápido.

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 finalizar 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 herdou. Tente escrever o código para isso e verifique se o código executa sem nenhum erro de compilação. Um pequeno conselho, você pode querer olhar para as classes abstratas em Scala.

Fique à vontade para colocar qualquer questão relacionada a este tutorial nos comentários abaixo.

Finalmente, não esqueça de matricular-se no novo curso de Scala no DataCamp, Introdução a Scala.