Programmeren in Java/Klassen

In dit hoofdstuk zullen we onze eerste klasse aanmaken en kort de basis bespreken. De klasse die we gaan maken is Car ofwel de auto die we in het vorige hoofdstuk hebben besproken.

Klasse aanmaken

Een klasse definiëren is redelijk eenvoudig, je gebruikt hiervoor de sleutelwoorden public en class. Dit wordt dan gevolgd door de naam van de klasse, in ons geval Car. class zal dus aanduiden dat we een klasse gaan definiëren, wat public betreft, daar komen we in een later hoofdstuk op terug. Er wordt dan een openende en sluitende accolade geschreven. Tussen die accolades gaan later de inhoud, dus de eigenschappen en methodes, komen.

public class Car {

}

Klassen kun je in hun eigen Java-bestand plaatsen, je moet dan wel als bestandsnaam dezelfde naam geven als de klasse die het bevat. Dus in dit geval Car.java. Nu we de klasse hebben gedefinieerd en bewaard willen we er een instantie van hebben, we moeten dus een object maken op basis van de klasse. Dit doen we als volgt:

public class Main {

    public static void main(String[] args) {
        Car myCar = new Car();
    }
}

Net zoals met primitieve datatypes vermelden we eerst het datatype, in dit geval Car, gevolgd door de naam die we willen geven aan ons object, net zoals gewone variabelnamen. We gebruiken dan het gelijkaanteken (=) om er een waarde aan te koppelen. We moeten dus een nieuwe instantie aanmaken van onze Car klasse, daarom gebruiken we het sleutelwoord new opnieuw gevolgd door de naam van de klasse met dan ronde haakje. Bovenstaande code zal uiteindelijk niets op het scherm tonen, want het enige wat we hebben gedaan is een instantie van Car aanmaken. Wil je controleren of je code goed werkt kun je myCar laten uitprinten, zoals als volgt:

public class Main {

    public static void main(String[] args) {
        Car myCar = new Car();
        System.out.println(myCar);
    }
}

Bovenstaande zal iets gelijkaardigs als onderstaande uitprinten.

Car@2eda0940

Wat je hier zit is de naam van de klasse gevolgd door een @ met daarna een uniek hexadecimaal nummer specifiek voor dit object. Hierdoor kun je meteen ook aantonen dat je telkens als je een instantie van een klasse aanmaakt, je telkens een nieuw object krijgt. We gaan daarvoor in onze main een tweede Car object aanmaken en die ook laten uitprinten.

public class Main {

    public static void main(String[] args) {
        Car myCar = new Car();
        Car myOtherCar = new Car();
        System.out.println(myCar);
        System.out.println(myOtherCar);
    }
}

Dit zal een gelijkaardige uitvoer geven als onderstaande.

Car@75bd9247
Car@7d417077

Je ziet dat beide een andere uniek nummer hebben, maar ook dat deze altijd een ander nummer zullen hebben telkens je de code opnieuw uitvoert.

Methodes

Nu hebben we wel een klasse, het heeft nog geen enkele functionaliteit. Daarvoor gaan we methodes toevoegen. We gaan onze Car de functionaliteit geven van remmen en rijden.

public class Car {

    public void drive() {
        System.out.println("De auto rijdt.");
    }
    
    public void brake() {
        System.out.println("De auto remt.");
    }
}

De methodes hebben we gedefinieerd met public gevolgd door void. void betekent dat onze methode geen waarde zal terug geven wanneer we de methode oproepen. We geven onze methodes hun namen gevolgd door haakjes en accolades. Tussen die accolades staat de functionaliteit die de methodes moeten uitvoeren telkens ze worden opgeroepen; in dit geval zullen ze "De auto rijdt." of "De auto remt." afprinten. Nu je de methodes hebt gedifinieerd kun je ze gebruiken. Bijvoorbeeld als volgt in de main:

public class Main {

    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.drive();
        myCar.brake();
    }
}

Dit geeft als uitvoer dan het volgende:

De auto rijdt.
De auto remt.

Eigenschappen

Eigenschappen, of ook wel velden genoemd, bevatten de gegevens van het object. Een eigenschap kan een primitieve datatype zijn zoals int of char, of instanties van klassen zoals String of een eigen gedefinieerde klasse. We gaan onze Car klasse een eigenschap geven die het type brandstof bijhoudt.

public class Car {

    public String typeOfFuel = "diesel";

    public void drive() {
        System.out.println("De auto rijdt met " + typeOfFuel + ".");
    }

    public void brake() {
        System.out.println("De auto remt.");
    }
}

Om een eigenschap aan te maken in een klasse gebruiken we opnieuw public gevolgd door het gewenste datatype met dan de naam van de eigenschap. We kunnen dan ook een waarde geven aan deze eigenschap en gebruiken in onze methodes, zoals we hier hebben gedaan bij drive. Als je drive nu zou oproepen krijg je het volgende:

De auto rijdt met diesel.

Net zoals variabelen kun je de waarden van eigenschappen veranderen. In onderstaande voorbeeld passen we het veld typeOfFuel aan naar benzine.

public class Main {

    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.drive();
        myCar.typeOfFuel = "benzine";
        myCar.drive();
    }
}

Dit zal de volgende output geven.

De auto rijdt met diesel.
De auto rijdt met benzine.

Net zoals methodes, kun je eigenschappen buiten de de klasse oproepen door simpelweg de naam van je object te vermelden, gevolgd door een punt met daarna de naam van de eigenschap. Je kunt op deze manier waardes van een object ophalen, maar ook waardes naar het object wegschrijven. Nu hebben we het type brandstof veranderd van diesel naar benzine, maar dit geeft wel een aantal problemen. In de echte wereld zou je ten eerste al niet zomaar een auto van type brandstof laten vervangen en zeker niet terwijl de auto in gebruik is. Auto's rollen niet uit de de fabriek als dieselauto's om dan omgebouwd te worden als benzineauto's. Neen, je wilt dat de auto het juiste brandstoftype heeft op het moment dat je de auto aanmaakt. Hier komen zogenaamde constructors van pas.

Constructors

Een constructor wordt aangeroepen op het moment dat er een nieuwe instantie van een klasse wordt gemaakt. Elke keer als het sleutelwoord new wordt gebruikt betekent dit dat er een constructor wordt aangeroepen. Nu hebben we tot nu toe met onze Car altijd een instantie kunnen maken met new, hoewel we geen constructor hebben gedefinieerd. Dit komt omdat als je in Java geen constructor zelf definieert, Java er voor jou een aanmaakt tijdens het compileren. Die impliciete constructor die dan wordt aangemaakt ziet er als volgt uit.

public class Car {

    public String typeOfFuel = "diesel";
    
    public Car() {
        
    }

    public void drive() {
        System.out.println("De auto rijdt met " + typeOfFuel + ".");
    }

    public void brake() {
        System.out.println("De auto remt.");
    }
}

Een constructor kun je aanmaken door public te vermelden gevolgd door de naam van de klasse. In tegenstelling tot een gewone methode heeft de constructor géén returntype, zelfs niet void. Een constructor is bedoeld om dus een nieuwe instantie van een klasse te initialiseren. Binnen de constructor kun je dus code schrijven die moet uitgevoerd worden wanneer je een object aanmaakt. We kunnen bij onze Car dan bijvoorbeeld het type brandstof bepalen.

public class Car {

    public String typeOfFuel;
    
    public Car() {
        typeOfFuel = "diesel";
    }

    public void drive() {
        System.out.println("De auto rijdt met " + typeOfFuel + ".");
    }

    public void brake() {
        System.out.println("De auto remt.");
    }
}

Nu heb je wellicht gemerkt dat wat we in bovenstaand voorbeeld hebben gedaan, niet veel is veranderd. We hebben enkel en alleen de plaats waar typeOfFuel wordt bepaald verhuisd van het veld naar de constuctor. Als je nu een nieuw Car object zou aanmaken zal die nog steeds diesel als standaard brandstof hebben. De oplossing is argumenten toe te voegen aan de constructor.

public class Car {

    public String typeOfFuel;
    
    public Car(String typeOfFuel) {
        this.typeOfFuel = typeOfFuel;
    }

    public void drive() {
        System.out.println("De auto rijdt met " + typeOfFuel + ".");
    }

    public void brake() {
        System.out.println("De auto remt.");
    }
}

Structuur

De structuur van een class is in feite simpel: binnen de definitie van een class worden velden en methoden beschreven. Hoewel het niet uitmaakt waar je wat vermeldt binnen de klasse is het best om volgende volgorde te behouden:

public class MyClass {

    // Velden of eigenschappen

    // Constructors

    // Methodes

}

Opnieuw, deze volgorde is niet verplicht, maar maakt de code leesbaarder.