Tratti di Scala

Introduzione a Scala. Dai un’occhiata!

Potresti essere anche 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 principalmente usato nella programmazione orientata agli oggetti, che può estendere la funzionalità di una classe usando un insieme di metodi.

Traits sono simili nello spirito ai interfacce nel linguaggio di programmazione Java. A differenza delle classi, i trait in Scala non possono essere istanziati e non hanno argomenti o parametri. Tuttavia, è possibile ereditarli (estenderli) usando classi e oggetti. Detto questo, i trait forniscono un insieme specifico di metodi/funzioni che eseguono un comportamento in 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 viene creato come una miscela di metodi che possono essere usati da classi diverse senza richiedere eredità multipla. Tuttavia, possono esserci eccezioni in cui due trait hanno un metodo con lo stesso nome (collocazione di nomi), che devono essere usati da una classe, nel qual caso l’ambiguità deve essere risolta esplicitamente.

I trait possono avere sia metodi astratti che non astratti come membri, così come campi. Quando non si inizializza un metodo in un trait, essi sono astratti, mentre quelli inizializzati vengono chiamati non astratti. Nei metodi astratti, la classe che implementa il trait si occupa dell’inizializzazione.

Ora, capiremo rapidamente i trait in Scala con l’aiuto di alcuni esempi!

Sintassi del Trait in Scala

La sintassi per il trait in Scala è semplice, viene definita dalla parola chiave trait seguita dal nome del trait.

trait Trait_Name{
// Variabili
// Metodi
}

Come si può vedere dalla definizione del tratto sopra, è stato definito un tratto chiamato DataCamp, che non ha variabili e metodi definiti al suo interno.

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

Come discusso nell’introduzione, i tratti Scala sono ereditati da una classe usando la parola chiave extends.

class Scala_Tutorial extends DataCamp{
// Variabili
// Metodi
}

Definiamo un tratto chiamato Scala_Course, che sarà ereditato dalla classe DataCamp. All’interno del trait, definirai un metodo astratto chiamato scala(), che sarà 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 quindi, la dichiarazione è stata fatta nella classe che ha ereditato quel tratto.

Ma cosa succede se hai un metodo (non astratto) che è già implementato nel tratto? Bene, in quel caso, la classe che estende questo tratto non deve implementare il metodo che è già implementato in un tratto.

Comprendiamo questo con l’aiuto di un piccolo esempio.

trait BMW{

    // traiettorie variabili
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // metodo traiettoria: 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{
    // variabili di classe
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

    // Metodo di 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  
{

    // Metodo principale
    def main(args: Array[String])  
    {

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

Eseguiamo il codice precedente:

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

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 precedente risulta in un errore, come mostrato qui sotto, poiché non hai definito il metodo traiettoria scala() (astratto) nella classe che l’ha ereditato.

Per far funzionare il codice precedente, potrebbero essere due soluzioni possibili:

• Definire il metodo scala() nella classe DataCamp o
• Definire la classe DataCamp come astratto.

L’ultimo argomento per questo tutorial è come puoi ereditare più traiettorie in una sola classe. Quindi, finiamola rapidamente.

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

    // Metodo principale
    def main(args: Array[String])  
    {

        // Oggetto di classe
        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 precedente.

Congratulazioni!

Congratulazioni per aver completato questo tutorial.

Ora sai cosa sono i Traits in programmazione e come utilizzarli in Scala. Un buon esercizio potrebbe essere cercare una soluzione per l’metodo astratto quando non è definito nella classe che lo eredita. Prova a scrivere il codice per lo stesso e vedi se il codice viene eseguito senza errori di compilazione. Un piccolo consiglio, forse vuoi guardare le Classi Astratte in Scala.

Sii libero di porre domande relative a questo tutorial nei commenti sottostanti.

Infine, non dimenticare di prendere il nuovo corso di Scala su DataCamp, Introduzione a Scala.