Scala Klassen en Objecten

DataCamp heeft recentelijk hun eerste cursus in Scala gelanceerd: Introductie tot Scala. Bekijk het!

Bekijk ook de volgende handleidingen:

• Beginners Guide to Scala
• IF ELSE in Scala
• Operators in Scala
• Lists in Scala

Introductie

In het algemeen bestaat Object-Oriented Programming (OOP) uit klassen en objecten en doet het pogingen om echte wereldobjecten als polymorfie en erfelijkheid uit te voeren.

OOP maakt ontwikkeling veel sneller en goedkapper en biedt betere softwareonderhoudbaarheid. De primaire reden voor deze magie is het aantal ondersteunde functies; u heeft klassen & objecten die makkelijk in de toekomst opnieuw kunnen worden gebruikt, gebaseerd op de vereisten, in tegenstelling tot een programma dat klassen & objecten ontbreekt. Dit leidt in zijn eigen tempo tot hogere kwaliteitsoftware, die ook uitbreidbaar is met nieuwe methodes en attributen.

Stel dat je een showroom van auto’s hebt; elke paar maanden wordt er een nieuwe auto gelanceerd, en om de bezoekers over de naam en features van de auto te informeren, moet je vanaf het begin nieuwe methoden en attributen definiëren. Echter, als je een objectgeoriënteerd programma hebt met een klasse ‘auto’, moet je maar een object voor de nieuwe auto toevoegen, dat de klassemethoden & attributen aanroep met de informatie van het voertuig.

Een klasse kan worden gezien als een weergave of ontwerp voor objecten. Klassen zullen meestal hun eigen methodes (gedrag) en attributen hebben.

Attributen zijn individuele entiteiten die elk object van elk ander onderscheiden en verschillende kenmerken van een object bepalen. Metodes zijn eigenlijk net als een functie meestal in programmatuur. Ze bepalen hoe de instantie van de klasse werkt. Het is vooral door de metodes (gedrag) dat objecten de macht krijgen om op ze iets te doen.

Het bovenstaande figuur geeft je meer intuïtie over de stroom van objectgeoriënteerd programmeren of, om precies te zijn, hoe een klasse eruitziet. In het bovenstaande plaatje is er een klasse auto die attributen: brandstof, max snelheid heeft, en kan er nog meer attributen aan krijgen zoals de model, merk, enzovoort. Het heeft verschillende sets van methodes zoals refuel(), getFuel(), setSpeed(), en sommige aanvullende methodes kunnen zijn change gear, start de motor, stop de motor, enzovoort.

Dus, als je over een specifieke auto spreekt, heb je een object, dat een instantie is van een klasse.

Nu laten we eens praten over objectgeoriënteerd programmeren in Scala.

Classes en Objecten in Scala

Net als in C++ en Java volgt objectgeoriënteerd programmeren in Scala bijna dezelfde conventies. Het heeft het concept van definiëren van classes en objecten binnen class constructors, en dat is alles wat er is aan objectgeoriënteerd programmeren in Scala.

Classedeclaratie

class Class_name{
// methoden en eigenschappen
}

Een klasse in Scala wordt gedefinieerd met het keyword class gevolgd door de naam van de klasse, en meestal begint de klassenaam met een hoofdletter. Er zijn een paar optionele sleutelwoorden die kunnen worden gebruikt in de Scala klassedeclaratie, zoals: class-naam, deze moet beginnen met een hoofdletter: superklasse, de naam van de bovenliggende klasse voorafgegaan door het keyword extend: traits, een door komma’s gescheiden lijst die door de klasse wordt geïmplementeerd, voorafgegaan door het keyword extend.

Een klasse kan in Scala maar één bovenliggende klasse erven, wat betekent dat Scala geen ondersteuning biedt voor meerdere erfgenamen. Dit kan echter bereikt worden met behulp van Traits.

Ten slotte is het lichaam van een klasse in Scala omsloten door accolades {}.

// Naam van de klasse is Car
class Car
{

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

    // Klassenmethode
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}
object Main  
{

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

        // Klasse-object
        var obj = new Car();
        obj.Display();
    }
}

Je kunt de bovenstaande code opslaan onder de naam class.scala en deze uitvoeren in de terminal via scala class.scala, en je zou de uitvoer moeten zien zoals hieronder.

Wel, de bovenstaande code maakt niet volledig gebruik van de mogelijkheden van een objectgeoriënteerd programma. Aangezien de uitvoer van de bovenstaande code onafhankelijk van het aantal keer dat je het uitvoert altijd hetzelfde resultaat zal geven. Je hebt statische variabelen gedefinieerd binnen de klasse, en de waarden van die variabelen blijven constant, zelfs als je oneindig veel nieuwe objecten aanmaakt. In het geval van een Mercedes Benz of een Ferrari auto kunt je niet van details verwachten.

Constructors in Scala

Constructors worden voornamelijk gebruikt om de status van het object te initialiseren. Deze initialisatie van het object gebeurt bij het aanmaken van het object, en ze worden slechts één keer aangeroepen.

Er zijn twee soorten constructors in Scala: Primary en Auxiliary. Voor deze tutorial zul je leren over de primaire constructor (Bron: O’Reilly).

class Class_name(Parameter_list){
// methoden, eigenschappen
}

De primaire constructor bevat hetzelfde lichaam als de klasse en wordt impliciet gemaakt samen met de definitie van de klasse. Het begint bij de definitie van de klasse en beslaat het gehele lichaam van de klasse. Ook als er maar één constructor is in het Scala programma, wordt dat bekend als een primaire constructor. Een primaire constructor kan zonder, met één of meer parameters worden gedefinieerd.

Nu neem ons dus het voorbeeld van eerder, maar deze keer voeg de primaire constructorfunctie eraan toe en observeer de effecten.

Ook hier zult u een nieuwe klassefeatures leren, namelijk dat een klasse meerdere objecten of instanties kan hebben, maar beide onafhankelijk van elkaar.

// Klasse naam is Auto
class Car(make: String, model: String, fuel: Int)
{

    // Klasse methode
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}

object Main

{

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

        // Meerdere Klasse objecten
        var obj1 = new Car("BMW", "X7", 40);
        var obj2 = new Car("Mercedes Benz", "S350D", 50);
        obj1.Display();
        obj2.Display();
    }
}

Laten we even de uitvoer bekijken:

Wat een uitmuntende prestatie, met behulp van een constructor was u in staat om meer effectieve resultaten te genereren.

Objecten declareren in Scala

Objecten declareren in Scala kan ook worden gezien als het instantiëren van een klasse of het aanroepen van een klasse. Net zoals klassen zijn objecten ook een fundamenteel onderdeel van het objectgeoriënteerde programmeren.

Een object kan uit drie kenmerken bestaan (Bron: GeeksforGeeks):

• Toestand: Eigenschappen van een object worden erdoor uitgedrukt. Het reflecteert ook de eigenschappen van een object.
• Gedrag: Methodes van een object worden erdoor uitgedrukt. Het reflecteert ook de reactie van een object op andere objecten.
• Identiteit: Het geeft een unieke naam aan een object en maakt het mogelijk om een object te interageren met andere objecten.

Kies de Hond als een object en bekijk het onderstaande diagram voor zijn identiteit, status en gedrag.

Alle instanties of objecten delen de klasse-attributen en methodes. Een enkele klasse kan meerdere objecten hebben, zoals je leerde hier. Echter, de status of waarden van elk object zijn uniek.

Tot slot zult u code schrijven die bestaat uit primaire constructors, klasse-variabelen, attributen en methodes, allemaal samengevat in één code.

Hieronder is een pictorale weergave van de componenten samengebracht in de klasse Motorcycle.

Het onderstaande code is vrij zelfverklarend; op een hoger niveau controleert het immers of de motorfiets-motor aan of uit is. Initieel wordt de motor aan de uitstand gezet, en het zal u van zijn status notifyen en deze uitschakelen.

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!

Gefeliciteerde op het voltooien van deze handleiding.

U kent nu hoe u classes en methodes declareert, objecten instantieert, hun attributen instelt en instance methodes aanroept in Scala. Deze concepten zullen u handig zijn niet alleen in Scala, maar ook in andere programmeer talen.

Programmeerconcepten gericht op objectgeoriënteerd zijn interessant en tegelijkertijd zeer krachtig. Ze voegen een nieuwe dimensie toe aan je code, maken het herbruikbaar. Als je programma groter wordt, zal je code in complexiteit toenemen. Er zit veel vlees in objectgeoriënteerde programmeerconcepten zoals erfelijkheid, polymorfisme, instance-methoden. Een andere krachtige eigenschap is Singleton. De ontwerpprincipes helpen je code meer gestructureerd en leesbaar te houden. Voor meer informatie over ontwerppatronen, overweeg het lezen van deze boek.

Voel je vrij om elke vraag die gerelateerd is aan deze handleiding in de commentaarsectie hieronder te stellen.

Ten slotte, vergeet niet de nieuwe Scala-cursus op DataCamp te volgen, Introduction to Scala.