Scala-Traits

DataCamp hat kürzlich seinen ersten Scala-Kurs veröffentlicht: Introduction to Scala. Schau ihn dir an!

Vielleicht interessieren dich auch diese Tutorials:

• Beginners Guide to Scala
• IF ELSE in Scala
• Operators in Scala
• Lists in Scala
• Scala Classes and Objects

Einleitung

Ein Trait ist ein Konzept, das vor allem in der objektorientierten Programmierung genutzt wird und über eine Reihe von Methoden die Funktionalität einer Klasse erweitern kann.

Traits sind vom Konzept her ähnlich wie Interfaces in der Programmiersprache Java. Anders als Klassen können Scala-Traits nicht instanziiert werden und nehmen keine Argumente oder Parameter an. Du kannst sie jedoch in Klassen und Objekten erben (extend). Traits stellen einen fest definierten Satz an Methoden/Funktionen bereit, die einer Klasse Verhalten mitgeben, und erwarten im Gegenzug, dass die Klasse bestimmte Methoden implementiert, die dieses Verhalten parametrisieren.

Ein Trait, das zur Definition eines Objekts verwendet wird, besteht aus einer Mischung von Methoden, die von unterschiedlichen Klassen genutzt werden können, ohne Mehrfachvererbung zu benötigen. Es kann jedoch Ausnahmen geben, wenn zwei Traits eine Methode mit demselben Namen besitzen (Namenskollision) und eine Klasse beide verwenden soll. In diesem Fall musst du die Mehrdeutigkeit explizit auflösen.

Traits können sowohl abstrakte als auch konkrete Methoden sowie Felder enthalten. Wenn du eine Methode in einem Trait nicht implementierst, ist sie abstrakt; implementierte Methoden sind konkret. Bei abstrakten Methoden übernimmt die Klasse, die das Trait implementiert, die Implementierung.

Schauen wir uns Scala-Traits jetzt schnell anhand einiger Beispiele an!

Scala-Trait-Syntax

Die Syntax für ein Scala-Trait ist unkompliziert: Sie beginnt mit dem Schlüsselwort trait, gefolgt vom Namen des Traits.

trait Trait_Name{
// Variables
// Methods
}
Bereitgestellt von

Wie du in der obigen Definition siehst, wurde ein Trait namens DataCamp angelegt, ohne dass darin Variablen oder Methoden definiert sind.

Als Nächstes ein einfaches Beispiel für Scala-Traits, das dir zeigt, wie sie im Code funktionieren.

Wie in der Einleitung besprochen, werden Scala-Traits über das Schlüsselwort extends von einer Klasse geerbt.

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

Definieren wir ein Trait namens Scala_Course, das von der Klasse DataCamp geerbt wird. Im trait legst du eine abstrakte Methode scala() an, die dann in der Klasse DataCamp implementiert wird.

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

Führen wir den obigen Code aus.

Im obigen Beispiel war die Methode scala() abstrakt. Daher wurde die Implementierung in der Klasse vorgenommen, die das Trait geerbt hat.

Was passiert, wenn eine Methode (nicht abstrakt) bereits im Trait implementiert ist? In diesem Fall muss die Klasse, die das Trait erweitert, diese Methode nicht erneut implementieren.

Schauen wir uns das an einem kleinen Beispiel an.

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();
    }
}
Bereitgestellt von

Führen wir den Code aus:

Nachdem du nun den Unterschied zwischen abstrakten und konkreten Methoden kennst, schauen wir uns an, was passiert, wenn eine abstrakte Methode in der Klasse, die sie erbt bzw. erweitert, nicht implementiert wird.

Verwenden wir dasselbe Beispiel, um das zu verdeutlichen.

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

Die Ausführung des obigen Codes führt zu einem Fehler, da die Trait-Methode scala() (abstrakt) in der erbenden Klasse nicht implementiert wurde.

Um den Code lauffähig zu machen, gibt es zwei mögliche Lösungen:

• Implementiere die Methode scala() in der Klasse DataCamp oder
• Markiere die Klasse DataCamp als abstract.

Zum Schluss schauen wir uns noch an, wie du mehrere Traits in einer Klasse erben kannst. Los geht's.

trait A{
// methods
}
trait B{
// methods
}
class C extends A with B{
}
Bereitgestellt von

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();
    }
}
Bereitgestellt von

Führen wir zum Abschluss auch diesen Code aus.

Glückwunsch!

Glückwunsch, du hast dieses Tutorial abgeschlossen.

Du weißt jetzt, was Traits in der Programmierung sind und wie du sie in Scala einsetzt. Eine gute Übung: Finde eine Lösung für den Fall, dass eine abstrakte Methode in der erbenden Klasse nicht definiert ist. Schreib entsprechenden Code und prüfe, ob er ohne Compilerfehler läuft. Kleiner Tipp: Schau dir abstrakte Klassen in Scala an.

Stell gern Fragen zu diesem Tutorial in den Kommentaren unten.

Und vergiss nicht, den neuen Scala-Kurs auf DataCamp zu belegen: Introduction to Scala.