Trait in Scala

DataCamp ha recentemente lanciato il suo primo corso su Scala: Introduction to Scala. Dagli un'occhiata!

Potresti anche essere interessato a leggere i seguenti tutorial:

• Guida per principianti a Scala
• IF ELSE in Scala
• Operatori in Scala
• Liste in Scala
• Classi e oggetti in Scala

Introduzione

Un trait è un concetto usato prevalentemente nella programmazione orientata agli oggetti, che può estendere la funzionalità di una classe tramite un insieme di metodi.

I trait sono simili, nello spirito, alle interfacce nel linguaggio Java. A differenza di una classe, i trait di Scala non possono essere istanziati e non hanno argomenti o parametri. Tuttavia, puoi ereditarli (estenderli) usando classi e oggetti. Detto questo, i trait forniscono un insieme specifico di metodi/funzioni che conferiscono un comportamento a una classe e si aspettano che la classe implementi un insieme di metodi che poi parametrizzano il comportamento fornito.

Un trait usato per definire un oggetto è creato come un insieme di metodi che possono essere utilizzati da classi diverse senza richiedere l'ereditarietà multipla. Tuttavia, possono esserci eccezioni in cui due trait hanno un metodo con lo stesso nome (collisione di nomi) che devono essere usati da una classe; in tal caso l'ambiguità va risolta esplicitamente.

I trait possono avere sia metodi, campi astratti sia non astratti come membri. Quando non inizializzi un metodo in un trait, esso è astratto, mentre quelli inizializzati sono detti non astratti. Nei metodi astratti, la classe che implementa il trait si occupa dell'inizializzazione.

Ora, capiamo rapidamente i trait di Scala con l'aiuto di alcuni esempi!

Sintassi dei trait in Scala

La sintassi di un trait in Scala è semplice: è definito dalla parola chiave trait seguita dal nome del trait.

trait Trait_Name{
// Variables
// Methods
}

Come puoi vedere dalla definizione del trait sopra, è stato definito un trait chiamato DataCamp, che non ha variabili né metodi al suo interno.

Passiamo a un semplice esempio di trait in Scala, che ti darà molta più chiarezza su come funzionano a livello di codice.

Come discusso nell'introduzione, i trait di Scala sono ereditati da una classe tramite la parola chiave extends.

class Scala_Tutorial extends DataCamp{
// Variables
// Methods
}

Definiamo un trait chiamato Scala_Course, che verrà ereditato dalla classe DataCamp. All'interno del trait definirai un metodo astratto chiamato scala(), che verrà definito nella 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()  
    }  
}

Ora eseguiamo il codice sopra.

Nell'esempio sopra, il metodo scala() era un metodo astratto e, di conseguenza, la dichiarazione è stata fatta nella classe che ha ereditato quel trait.

Ma cosa succede se hai un metodo (non astratto) già implementato nel trait? In tal caso, la classe che estende questo trait non ha bisogno di implementare il metodo già implementato nel trait.

Capisci questo con l'aiuto di un piccolo esempio.

trait BMW{

    // trait variables
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // trait method: NON-ABSTRACT
    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{
    // class variables
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

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

object Main  
{

    // Main method
    def main(args: Array[String])  
    {

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

Eseguiamo il codice sopra:

Ora che hai capito la differenza tra metodi abstract e non-abstract, vediamo cosa può andare storto quando un metodo abstract non è implementato nella classe che lo eredita o lo estende.

Usiamo lo stesso esempio per capire questo concetto.

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

L'esecuzione del codice sopra genera un errore, come mostrato sotto, poiché non hai definito il metodo del trait scala() (astratto) nella classe che lo ha ereditato.

Per far funzionare il codice sopra, ci sono due possibili soluzioni:

• Definire il metodo scala() nella classe DataCamp oppure
• Definire la classe DataCamp come abstract.

L'ultimo argomento del tutorial di oggi è come puoi ereditare più trait in un'unica classe. Quindi, concludiamo rapidamente.

trait A{
// methods
}
trait B{
// methods
}
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  
{

    // Main method
    def main(args: Array[String])  
    {

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

Infine, eseguiamo il codice sopra.

Congratulazioni!

Congratulazioni per aver completato questo tutorial.

Ora sai cosa sono i trait in programmazione e come usarli in Scala. Un buon esercizio per te sarebbe trovare una soluzione per il metodo astratto quando non è definito nella classe che lo ha ereditato. Prova a scrivere il codice e verifica se viene eseguito senza errori di compilazione. Un piccolo suggerimento: potresti dare un'occhiata alle classi astratte in Scala.

Sentiti libero di fare qualsiasi domanda su questo tutorial nella sezione commenti qui sotto.

Infine, non dimenticare di seguire il nuovo corso su Scala di DataCamp, Introduction to Scala.