Scala-Eigenschaften

DataCamp hat kürzlich ihr erstes Kursus in Scala gestartet: Einführung in Scala. Probiere es aus!

Vielleicht interessiert dich auch folgendes Tutorial:

• Anfängeranleitung für Scala
• IF ELSE in Scala
• Operatoren in Scala
• Listen in Scala
• Scala-Klassen und Objekte

Einführung

Ein Trait ist ein Konzept, das hauptsächlich in objektorientiertem Programmieren verwendet wird und die Funktionalität einer Klasse mit einer Methode-Satz erweitern kann.

Traits entsprechen in ihrer Natur den Interfaces in der Programmiersprache Java. Anders als Klassen können Scala-Traits nicht instanziert werden und haben keine Argumente oder Parameter. Allerdings können sie von Klassen und Objekten erbt (erweitert) werden. Mit anderen Worten,Traits stellen eine bestimmte Reihe von Methoden/Funktionen bereit, die Verhalten in einer Klasse ausführen und erwarten, dass die Klasse eine Reihe von Methoden implementiert, die das bereitgestellte Verhalten parametrisieren.

Ein Trait, das verwendet wird, um ein Objekt zu definieren, ist eine Mischung aus Methoden, die von verschiedenen Klassen ohne multiple Vererbung verwendet werden können. Allerdings können es Ausnahmen geben, in denen zwei Traits eine Methode mit demselben Namen haben (Namenskollision), die von einer Klasse verwendet werden müssen, in diesem Fall muss die Mehrdeutigkeit explizit aufgelöst werden.

Traits können sowohl abstrakte als auch nicht-abstrakte Methoden, sowie Felder als Mitglieder haben. Wenn du in einem Trait keine Methode initialisierst, ist sie abstrakt, während die initialisierten als nicht-abstrakt bezeichnet werden. In abstrakten Methoden kümmert sich die Klasse, die das Trait implementiert, um die Initialisierung.

Nun, lassen Sie uns Scala-Traits mit Hilfe einiger Beispiele schnell verstehen!

Syntax von Scala Traits

Die Syntax für Scala-Traits ist einfach, sie wird durch das Schlüsselwort trait gefolgt vom Namen des Traits definiert.

trait Trait_Name{
// Variablen
// Methoden
}

Wie Sie aus der oben gezeigten Trait-Definition erkennen können, wurde eine Trait namens DataCamp definiert, die keine Variablen und Methoden enthält.

Lassen Sie uns zu einem einfachen Beispiel von Scala-Traits gehen, das Ihnen mehr Klarheit über ihre programmtechnische Arbeitsweise geben wird.

Wie in der Einführung besprochen, werden Scala-Traits von einer Klasse durch den Benutz des Schlüsselworts extends geerbt.

class Scala_Tutorial extends DataCamp{
// Variablen
// Methoden
}

Legen wir eine Trait namens Scala_Course definieren, die von der Klasse DataCamp erben wird. Innerhalb der trait definieren wir einen abstrakten Methoden namens scala(), der in der Klasse DataCamp definiert werden 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()  
    }  
}

Lassen Sie uns nun das obige Code ausführen.

In dem obigen Beispiel war die Methode scala() eine abstrakte Methode, daher wurde die Deklaration in der Klasse erstellt, die diese Trait erbt.

Wie aber, wenn Sie eine Methode (nicht abstrakt) bereits in der Trait implementiert haben? Na ja, in dem Fall muss die Klasse, die diese Trait erweitert, die Methode nicht implementieren, die bereits in der Trait implementiert ist.

Lassen Sie uns dies mit Hilfe eines kleinen Beispiels verstehen.

trait BMW{

    // Trait-Variablen
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // Trait-Methode: NICHT 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{
    // Klasse-Variablen
    var make1: String = "Mercedes Benz"
    var model1: String = "S350D"
    var fuel1: Int = 50

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

object Main  
{

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

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

Lass uns den oben stehenden Code ausführen:

Nun, da du die Unterschiede zwischen abstract und non-abstract Methoden verstanden hast, lass uns sehen, was falsch laufen kann, wenn eine abstract Methode in einer Klasse, die inherits oder extends sie, nicht implementiert wird.

Verwenden wir den selben Beispiel, um dieses Konzept zu verstehen.

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

Die Ausführung des obenstehenden Codes führt zu einem Fehler, wie unten gezeigt, da du die Trait-Methode scala() (abstract) in der Klasse, die sie geerbt hat, nicht definiert hast.

Um den obenstehenden Code zu funktionieren, könnten zwei mögliche Lösungen sein:

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

Der letzte Thema für heute ist, wie du in einer Klasse mehrere Traits erben kannst. Also lass uns das schnell abschließen.

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

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

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

Schließlich lassen Sie das oben stehende Code ausführen.

Glückwunsch!

Glückwunsch, Sie haben dieses Tutorial beendet.

Sie kennen nun, was Traits in der Programmierung sind und wie Sie sie in Scala verwenden können. Ein gutes Übungsprojekt könnte es sein, eine Lösung für das abstrakte Verfahren zu finden, wenn es in der Klasse, die es erbt, nicht definiert ist. Versuchen Sie, den gleichen Code zu schreiben und zu sehen, ob der Code ohne Compilierfehler ausgeführt wird. Ein kleiner Tipp, Sie könnten sich auf Abstract Classes in Scala konzentrieren.

Bitte lassen Sie sich ungehindert Fragen zu diesem Tutorial in der Kommentarzeile unten stellen.

Abschließend vergessen Sie nicht, den neuen Scala-Kurs auf DataCamp, Einführung in Scala, zu belegen.