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.
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()}classDataCampextendsScala_Course{
def scala(){println("DataCamp has recently launched there first Scala course")}}
object Main{
def main(args:Array[String]){var a =newDataCamp()
a.scala()}}Mogelijk gemaakt door
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 variablesvarmake: String ="BMW"varmodel: String ="X7"varfuel: 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);}}classCarextendsBMW{// class variablesvarmake1: String ="Mercedes Benz"varmodel1: String ="S350D"varfuel1: 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 objectvar obj =newCar();println("Calling the Class Method")
obj.Merc_Specs();println("Calling the Trait Method")
obj.Display();}}Mogelijk gemaakt door
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()}classDataCampextendsScala_Course{
def print(){println("Error: Class DataCamp needs to be Abstract")}}
object Main{
def main(args:Array[String]){var a =newDataCamp()
a.print()}}Mogelijk gemaakt door
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 BMW{varmake: String ="BMW"varmodel: String ="X7"varfuel: Int =40}
trait Merc{varmake1: String ="Mercedes Benz"varmodel1: String ="S350D"varfuel1: Int =50}classCarextendsBMWwith 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 objectvar obj =newCar();println("Calling the BMW Trait")
obj.BMW_Specs();println();println("Calling the Merc Trait")
obj.Merc_Specs();}}Mogelijk gemaakt door
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.
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
traitgevolgd door de naam van de trait.Zoals je in bovenstaande trait-definitie ziet, is een trait met de naam
DataCampgedefinieerd, 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.Definieer een trait met de naam
Scala_Course, die wordt overgeërfd door de classDataCamp. Binnen detraitdefinieer je een abstracte methode genaamdscala(), die in deDataCamp-class zal worden gedefinieerd.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.
Laten we de bovenstaande code uitvoeren:
Nu je het verschil tussen
abstractenniet-abstracte methoden begrijpt, kijken we wat er mis kan gaan wanneer eenabstractemethode niet wordt geïmplementeerd in de class die dezeovererftofuitbreidt.Laten we hetzelfde voorbeeld gebruiken om dit concept te begrijpen.
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:
scala()in de classDataCampofabstract.Het laatste onderwerp voor vandaag is hoe je meerdere traits in één class kunt overerven. Laten we dit snel afronden.
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.