Scala-kenmerken

DataCamp heeft onlangs hun eerste Scala-cursus gelanceerd: Introductie tot Scala. Bekijk het uit!

Je bent misschien ook geïnteresseerd in het lezen van de volgende tutorials:

• Gids voor beginners in Scala
• IF ELSE in Scala
• Operatoren in Scala
• Lijsten in Scala
• Scala Classes en Objecten

Introductie

Een Trait is een concept dat voornamelijk wordt gebruikt in objectgeoriënteerd programmeren, en kan de functionaliteit van een klasse uitbreiden door gebruik te maken van een set methoden.

Traits zijn vergelijkbaar in geest met interfaces in de Java Programmeertaal. Contrariërend aan een klasse, kunnen Scala-traits niet worden geïnstantieerd en hebben geen argumenten of parameters. Wel kunnen ze worden geërfd (uitgebreid) door klassen en objecten. Traits bieden een specifieke set aan methodes/functies die een klasse gedrag uitvoeren en verwachten dat de klasse een set aan methodes implementeert die dit aangeboden gedrag parameteriseren.

Een trait die wordt gebruikt om een object te definiëren, wordt gecreëerd als een mengsel van methodes die door verschillende klassen kunnen worden gebruikt zonder meerdere erfelden. Echter, er kunnen uitzonderingen zijn waarin twee traits een methode hebben met dezelfde naam (naamconflicten), die door een klasse moeten worden gebruikt, in welk geval de ambiguïteit expliciet moet worden opgelost.

Traits kunnen zowel abstracte als niet-abstracte methodes, velden als leden hebben. Als u een methode in een trait niet initialiseert, zijn ze abstract, terwijl de geïnitialiseerde methodes deel uitmaken van een niet-abstracte trait. Abstracte methodes worden door de klasse die de trait implementeert behandeld.

Laten we nu snel Scala-traits door enkele voorbeelden begrijpen!

Scala Trait Syntax

De syntaxis voor de Scala-trait is eenvoudig, gedefinieerd door het keyword trait gevolgd door de naam van de trait.

trait Trait_Name{
// Variabelen
// Methodes
}

Zoals u uit de bovenstaande definitie van de eigenschap ziet, is een eigenschap genaamd DataCamp gedefinieerd, die geen variabelen en methodes binnen zich heeft gedefinieerd.

Laten we nu overgaan naar eenvoudige voorbeelden van Scala-traits, die u veel helderder zullen maken hoe ze programmatisch werken.

ALS gezegd werd in de introductie, worden Scala-traits geërfd door een klasse met behulp van het sleutelwoord extends.

class Scala_Tutorial extends DataCamp{
// Variabelen
// Methodes
}

Definieer nu een klasse genaamd Scala_Course, die door de klasse DataCamp geërfd wordt. Binnen het trait definieer je een abstracte methode genaamd scala(), die in de DataCamp klasse gedefinieerd zal worden.

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

Laten we nu bovenstaand code uitvoeren.

In het bovenstaande voorbeeld was de methode scala() een abstracte methode, en dus werd de declaratie gemaakt in de klasse die dit kenmerk erfde.

Maar wat als u een methode (niet-abstract) al gecodeerd heeft in het kenmerk? Wellicht hoeft de klasse die dit kenmerk uitbreidt de methode die al in een kenmerk is gedefinieerd niet opnieuw te implementeren.

Laat ons dit met behulp van een klein voorbeeld verduidelijken.

trait BMW{

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

    // trait methode: 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{
    // klasse variabelen
    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  
{

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

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

Laten we de bovenstaande code uitvoeren:

Nu u de verschillen tussen abstract en non-abstract methoden heeft begrepen, laten we kijken wat er mis kan gaan als een abstract methode niet wordt geïmplementeerd in de klasse die hem erft of uitbreidt.

Gebruik ons hetzelfde voorbeeld om dit concept te begrijpen.

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

Als u bovenstaande code uitvoert, zal u een foutmelding zien, zoals hieronder getoond, omdat u de traitmethode scala() (abstract) niet heeft gedefinieerd in de klasse die hem erft.

Om de bovenstaande code te laten werken, kunnen er twee mogelijke oplossingen zijn:

• Defineer de methode scala() in de klasse DataCamp of
• Defineer de DataCamp klasse als abstract.

Het laatste onderwerp voor deze les is hoe u meerdere traits in één klasse kunt erfden. Laat ons die snel afwerken.

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

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

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

Tot slot laten we de bovenstaande code uitvoeren.

Gefeliciteerd!

Gefeliciteerd met het voltooien van deze handleiding.

U kent nu wat Traits zijn in programmeren en hoe u ze in Scala kunt gebruiken. Een goed oefening voor u zou zijn om een oplossing te vinden voor het abstracte methodes bij het niet zijn definiëren in de klasse die het erven. Probeer code voor dezelfde te schrijven en zie of de code zonder enige compilatiefout wordt uitgevoerd. Een kleine tip, u zou misschien willen kijken naar Abstracte Klassen in Scala.

Vraagt u zich geen lastige vragen aan te kunnen stellen die gerelateerd zijn aan deze handleiding in het reactiegedeelte hieronder.

Tot slot, vergeet niet om de nieuwe Scala-cursus op DataCamp aan te nemen, Introductie tot Scala.