Cursus
Introduction to Scala
3 uur
27.2K
DataCamp heeft onlangs hun eerste Scala-cursus gelanceerd: Introduction to Scala. Check 'm!
Bekijk ook de volgende tutorials:
Introductie
In het algemeen bestaat objectgeoriënteerd programmeren (OOP) uit klassen en objecten en is het bedoeld om entiteiten uit de echte wereld te implementeren, zoals polymorfisme en overerving.
OOP maakt ontwikkeling een stuk sneller en goedkoper, met betere onderhoudbaarheid van software. De belangrijkste reden hiervoor is het aantal functies dat het ondersteunt; je hebt klassen & objecten die je in de toekomst eenvoudig opnieuw kunt gebruiken op basis van de behoefte, in tegenstelling tot een programma zonder klassen & objecten. Dit leidt op zijn beurt tot software van hogere kwaliteit, die ook uitbreidbaar is met nieuwe methoden en attributen.
Stel: je hebt een showroom met auto's; elke paar maanden komt er een nieuw model uit, en om het publiek te informeren over de naam en de features moet je telkens vanaf nul nieuwe methoden en attributen definiëren. Maar als je een objectgeoriënteerd programma hebt met een klasse car, voeg je alleen een object voor die nieuwe auto toe, dat de klassmethoden & attributen aanroept met de gegevens van het voertuig.
Je kunt een klasse zien als een representatie of ontwerp voor objecten. Klassen hebben meestal hun eigen methoden (gedrag) en attributen.
Attributen zijn afzonderlijke entiteiten die elk object van het andere onderscheiden en verschillende eigenschappen van een object bepalen. Methoden werken daarentegen meer zoals een functie in programmeren doorgaans werkt. Ze bepalen hoe de instantie van de klasse functioneert. Het is vooral dankzij methoden (gedrag) dat er iets met objecten gedaan kan worden.
De bovenstaande figuur geeft je meer intuïtie over de flow van objectgeoriënteerd programmeren of, specifieker, hoe een klasse eruitziet. In de afbeelding staat een class car met attributes: fuel, max speed, en er kunnen meer attributen zijn zoals model, make, enz. Hij heeft verschillende sets methods zoals refuel(), getFuel(), setSpeed(), en aanvullende methoden kunnen zijn change gear, start the engine, stop the engine, enz.
Wanneer je het over een specifieke auto hebt, heb je een object, oftewel een instantie van een klasse.
Nu gaan we het hebben over objectgeoriënteerd programmeren in Scala.
Klassen en objecten in Scala
Net als in C++ en Java volgt objectgeoriënteerd programmeren in Scala grotendeels dezelfde conventies. Het kent het concept van classes en objects en binnen een klasse constructors, en dat is in grote lijnen waar OOP in Scala op neerkomt.
Klasse declareren
class Class_name{
// methods and attributes
}
Een klasse in Scala wordt gedefinieerd met het sleutelwoord class gevolgd door de naam van de klasse, en over het algemeen begint de klassenaam met een hoofdletter. Er zijn een paar optionele elementen die je kunt gebruiken in een Scala-klassedeclaratie, zoals: class-name, die met een hoofdletter moet beginnen; superclass, de naam van de bovenliggende klasse voorafgegaan door het sleutelwoord extend; traits, een door komma's gescheiden lijst die door de klasse wordt geïmplementeerd en voorafgegaan door het sleutelwoord extend.
Een klasse kan in Scala slechts één bovenliggende klasse erven, wat betekent dat Scala geen multiple inheritance ondersteunt. Dat kun je echter bereiken met behulp van Traits.
Ten slotte wordt de body van een klasse in Scala omgeven door accolades {}.
// Name of the class is Car
class Car
{
// Class variables
var make: String = "BMW"
var model: String = "X7"
var fuel: Int = 40
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Car();
obj.Display();
}
}
Je kunt de bovenstaande code opslaan onder de naam class.scala en uitvoeren in de terminal met scala class.scala; je zou dan onderstaande output moeten zien.
De bovenstaande code benut niet volledig de mogelijkheden van een objectgeoriënteerd programma. De output zal namelijk steeds hetzelfde zijn, ongeacht hoe vaak je het uitvoert. Je hebt statische variabelen binnen de klasse gedefinieerd, en de waarden daarvan blijven constant, zelfs als je oneindig veel nieuwe objecten maakt. Conclusie: je kunt er niet mee rekenen op details voor een Mercedes-Benz of een Ferrari.
Constructor in Scala
Constructors worden voornamelijk gebruikt om de status van een object te initialiseren. Dit initialiseren gebeurt op het moment dat het object wordt gemaakt en ze worden slechts één keer aangeroepen.
Er zijn twee soorten constructors in Scala: Primary en Auxiliary. In deze tutorial leer je over de primaire constructor (Bron: O'Reilly).
class Class_name(Parameter_list){
// methods, attributes
}
De primaire constructor deelt dezelfde body met de klasse en wordt impliciet aangemaakt samen met de klassedefinitie. Hij begint bij de klassedefinitie en beslaat de volledige body van de klasse. Als er slechts één constructor in het Scala-programma is, heet die de primaire constructor. Een primaire constructor kan nul, één of meer parameters hebben.
Laten we dus het vorige voorbeeld nemen, maar dit keer de primaire constructor eraan toevoegen en het effect bekijken.
Hier leer je ook een nieuwe eigenschap van een klasse: een klasse kan meerdere objecten of instanties hebben die onafhankelijk van elkaar zijn.
// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Multiple Class object
var obj1 = new Car("BMW", "X7", 40);
var obj2 = new Car("Mercedes Benz", "S350D", 50);
obj1.Display();
obj2.Display();
}
}
Laten we snel naar de output kijken:
Mooi, toch? Met behulp van een constructor kon je effectievere resultaten genereren.
Objecten declareren in Scala
Objecten declareren in Scala kun je ook zien als een klasse instantiëren of een klasse aanroepen. Net als klassen zijn objecten ook een fundamentele bouwsteen van objectgeoriënteerd programmeren.
Een object kan drie kenmerken hebben (Bron: GeeksforGeeks):
State:Attributen van een object representeren het. Ze weerspiegelen ook de eigenschappen van een object.Behavior:Methoden van een object representeren het. Ze weerspiegelen ook de reactie van een object op andere objecten.Identity:Geeft een unieke naam aan een object en maakt het voor een object mogelijk om met andere objecten te interageren.
Beschouw Hond als een object en bekijk onderstaand diagram voor zijn identiteit, status en gedrag.
Alle instanties of objecten delen de klasse-attributen en -methoden. Eén enkele klasse kan meerdere objecten hebben, zoals je hier hebt geleerd. De status of waarden van elk object zijn echter uniek.
Tot slot schrijf je een code waarin primaire constructors, klassvariabelen, attributen en methoden allemaal in één geheel zijn gecombineerd.
Hieronder zie je een visuele weergave van de componenten die samenkomen in de klasse Motorcycle.
De onderstaande code spreekt grotendeels voor zich; op hoofdlijnen controleert hij of de motor van de motorfiets on of off is. Aanvankelijk staat de motor uit, en daarover krijg je een melding en wordt hij aangezet.
class Motorcycle(make:String,color:String) {
var engineState: Boolean = false;
def startEngine() {
if (engineState == true){
println("The engine is already on.");
}
else {
engineState = true
println("The engine is now on.");
}
}
def showAtts() {
println("This motorcycle is a "+ color + " " + make);
if (engineState == true){
println("The engine is on.");
}
else{
println("The engine is off.");
}
}
}
object Main
{
def main (args: Array[String])
{
var m = new Motorcycle("BMW K 1600 GTL","White");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
println("------");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
}
}
Gefeliciteerd!
Gefeliciteerd met het afronden van deze tutorial.
Je weet nu hoe je klassen en methoden declareert, objecten instantieert, hun attributen instelt en instantiemethoden aanroept in Scala. Deze concepten zijn niet alleen in Scala nuttig, maar ook in andere programmeertalen.
Concepten uit objectgeoriënteerd programmeren zijn interessant en tegelijk erg krachtig. Ze voegen een nieuwe dimensie toe aan je code en maken die herbruikbaar. Naarmate je programma groter wordt, groeit ook de complexiteit van je code. Er zit veel inhoud in OOP-concepten zoals overerving, polymorfisme en instantiemethoden. Een andere krachtige feature is Singleton. De ontwerpbeginselen helpen je code gestructureerder en leesbaarder te houden. Voor meer over design patterns kun je dit boek lezen.
Stel gerust vragen over deze tutorial in de reacties hieronder.
Vergeet tot slot niet de nieuwe Scala-cursus op DataCamp te volgen, Introduction to Scala.
Onderwerpen
