Scala-traits

Leer over het gebruik van traits in Scala met behulp van syntactische voorbeelden.

Bijgewerkt 2 okt 2026 · 6 min lezen

Verken met AI

DataCamp heeft onlangs hun eerste Scala-cursus gelanceerd: Introductie tot Scala. Check it out!

Misschien vind je de volgende tutorials ook interessant:

Introductie

Een trait is een concept dat vooral wordt gebruikt in objectgeoriënteerd programmeren en kan de functionaliteit van een class uitbreiden met een set methoden.

Traits lijken qua idee op interfaces in de programmeertaal Java. In tegenstelling tot een class kunnen Scala-traits niet worden geïnstantieerd en hebben ze geen argumenten of parameters. Je kunt ze echter wel overerven (extenden) met classes en objecten. Traits bieden een specifieke set methoden/functies die gedrag aan een class toevoegen en verwachten dat de class een set methoden implementeert die dat geleverde gedrag vervolgens parametriseren.

Een trait die wordt gebruikt om een object te definiëren, wordt opgezet als een mix van methoden die door verschillende classes kunnen worden gebruikt zonder meervoudige overerving te vereisen. Er kunnen echter uitzonderingen zijn waarbij twee traits een methode met dezelfde naam hebben (naamconflict) die door een class moet worden gebruikt; in dat geval moet de dubbelzinnigheid expliciet worden opgelost.

Traits kunnen zowel abstracte als niet-abstracte methoden en velden als leden hebben. Als je een methode in een trait niet initialiseert, is die abstract; de geïnitialiseerde methoden heten niet-abstract. Bij abstracte methoden zorgt de class die de trait implementeert voor de initialisatie.

Laten we nu snel Scala-traits begrijpen aan de hand van een paar voorbeelden!

Scala-trait-syntax

De syntax voor de Scala-trait is eenvoudig: deze wordt gedefinieerd door het sleutelwoord trait gevolgd door de naam van de trait.

trait Trait_Name{
// Variables
// Methods
}

Zoals je in bovenstaande trait-definitie ziet, is een trait met de naam DataCamp gedefinieerd, waarin geen variabelen en methoden zijn opgenomen.

Laten we doorgaan met een eenvoudig voorbeeld van Scala-traits, dat je veel meer duidelijkheid geeft over hoe ze programmatisch werken.

Zoals besproken in de introductie, worden Scala-traits door een class overgeërfd met het sleutelwoord extends.

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

Definieer een trait met de naam Scala_Course, die wordt overgeërfd door de class DataCamp. Binnen de trait definieer je een abstracte methode genaamd scala(), die in de DataCamp-class zal worden gedefinieerd.

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 de bovenstaande code uitvoeren.

In het bovenstaande voorbeeld was de methode scala() een abstracte methode, en daarom werd de declaratie gedaan in de class die die trait overerfde.

Maar wat als je een (niet-abstracte) methode hebt die al in de trait is geïmplementeerd? In dat geval hoeft de class die deze trait uitbreidt de methode die al in een trait is geïmplementeerd niet nogmaals te implementeren.

Laten we dit begrijpen met behulp van een klein voorbeeld.

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

Laten we de bovenstaande code uitvoeren:

Nu je het verschil tussen abstract en niet-abstracte methoden begrijpt, kijken we wat er mis kan gaan wanneer een abstracte methode niet wordt geïmplementeerd in de class die deze overerft of uitbreidt.

Laten we hetzelfde voorbeeld gebruiken 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()  
    }  
}

Het uitvoeren van de bovenstaande code resulteert in een fout, zoals hieronder weergegeven, omdat je de trait-methode scala() (abstract) niet hebt gedefinieerd in de class die deze overerfde.

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

Definieer de methode scala() in de class DataCamp of
Definieer de class DataCamp als abstract.

Het laatste onderwerp voor vandaag is hoe je meerdere traits in één class kunt overerven. Laten we dit snel afronden.

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

Tot slot voeren we de bovenstaande code uit.

Gefeliciteerd!

Gefeliciteerd met het afronden van deze tutorial.

Je weet nu wat traits in programmeren zijn en hoe je ze in Scala gebruikt. Een goede oefening voor jou is om een oplossing te vinden voor de abstracte methode wanneer die niet is gedefinieerd in de class die deze heeft overgeërfd. Probeer hiervoor code te schrijven en kijk of de code zonder compileerfout draait. Kleine tip: je wilt misschien kijken naar abstracte classes in Scala.

Stel gerust vragen over deze tutorial in de reacties hieronder.

Vergeet tot slot niet de nieuwe Scala-cursus op DataCamp te volgen, Introductie tot Scala.

Onderwerpen

Scala