Hoofdstuk 1: Klassen en Objecten

Inleiding

Objectgeoriënteerd maakt het mogelijk om grootschalige projecten op te bouwen en te onderhouden voorzien van Grafische gebruikersinterfaces

  • In de cursus "Computers en programmeren" heb je veel problemen kunnen oplossen via programmeertechnieken zoals keuzes (if-else,switch), lussen (while,do-while,for), methodes en arrays. Echter, enkel deze technieken zijn niet genoeg om grafische gebruikersinterfaces te gaan maken of om grote programma's en sofwareprojecten op te bouwen.
  • Veronderstel dat we een grafische gebruikersinterface willen ontwerpen, hoe zou je die opbouwen?

Definiëren van klassen voor objecten

  • Objectgeoriënteerd programmeren (OOP) omvat het gebruik van objecten om programma's te maken. Een object stelt een entiteit voor die een realiteit kan gedefinieerd worden. Bijvoorbeeld, een student, een bureau, een cirkel, een knop of zelfs een lening kan je zien als objecten.

  • Een object wordt opgebouwd uit 3 elementen : een unieke identiteit, een toestand een een gedrag.

    • De toestand van een object wordt voorgesteld door gegevensvelden of variabelen waarin waardes kunnen toegekend worden. De toestand wordt ook wel de eigenschappen of attributen genoemd. Bijvoorbeeld. En object cirkel heeft een veld straal omdat dit een eigenschap is die de cirkel definieert. Een rechthoek heeft als gegevensvelden hoogte en breedte.
    • Het gedrag van een object wordt gedefinieerd door methodes die het object kan uitvoeren. Dit wordt ook wel acties genoemd. Als een methode uitgevoerd wordt, dan wordt er gevraagd aan het object om een actie uit te voeren. Bijvoorbeeld, een cirkel object kan methodes uitvoeren om de oppervlakte of de optrek te meten. We definieren dan methodes berekenOppervlakte of berekenOmtrek voor cirkel objecten. Een cirkle object kan de methode berekenOppervlakte uitvoeren, dat dan het resultaat van die berekening teruggeeft. Een cirkel object kan ook een methode hebben die eigenschappen van die cirkel kunnen veranderen. Bijvoorbeeld, de methode setStraal(getal) kan de straal veranderen naar een nieuwe waarde getal.

  • Objecten van eenzelfde type worden gedefinieerd in een gemeenschappelijke klasse. Een klasse is een sjabloon, een bouwplan of een contract dat de gegevensvelden en methodes van objecten beschrijft.

  • Een object is dan een instantie van die klasse. Er kunnen meerdere objecten gemaakt worden van een klasse. Bijvoorbeeld, kan je meerdere huizen bouwen met eenzelfde bouwplan.

  • Java gebruikt variabelen om gegevensvelden te definiëren en methodes om het gedrag te definieren. Daarenboven, heeft Java speciale methodes die de objecten maken, zogenaamde constructor. Een constructor zijn speciaal ontworpen voor objecten te initializeren, zoals de initializatie van gegevensvelden.

  • Een voorbeeld van een klasse wordt hieronder weergegeven:

class Cirkel { // Hier komen de gegevensvelden double straal; // de straal van de cirkle // Hier komen de constructoren Cirkel() { // Maak een cirkel object } Cirkel(double nieuweStraal) { // Maak een cirkel object met een gegeven straal straal = nieuweStraal; } /** Bereken de oppervlakte */ double berekenOppervlakte(){ return straal * straal * Math.PI; } /** Bereken de omtrek */ double berekenOmtrek(){ return 2 * straal * Math.PI; } /** Stel nieuwe straal in */ void setStraal(double nieuweStraal) { straal = nieuweStraal; } }
  • De voorgaande klasse is anders dan de vorige programma's die we in de vorige cursus gemaakt hebben. Het bevat geen main methode, en het kan daarom niet uitgevoerd worden. De klasse is enkel een definitie voor cirkelobjecten.

Voorbeeld: Definiëren van Klassen en maken van objecten

Klassen zijn definities voor objecten en objecten worden gemaakt vanuit een klasse

  • Het onderstaand programma zal 3 cirkelobjecten maken met straal 1, 25 en 125 en zal de straal en de omtrek tonen op het scherm. Daarna wordt de tweede cirkel veranderd en wordt opnieuw de straal getoond en de omtrek berekend.
public class TestCirkel { /** Main methode */ public static void main(String[] args) { // Maak een cirkel met straal 1 Cirkel cirkel1 = new Cirkel(); System.out.println("De oppervlakte van de cirkel met straal " + cirkel1.straal + " is " + cirkel1.berekenOppervlakte()); // Maak een cirkel met straal 25 Cirkel cirkel2 = new Cirkel(25); System.out.println("De oppervlakte van de cirkel met straal " + cirkel2.straal + " is " + cirkel2.berekenOppervlakte()); // Maak een cirkel met straal 125 Cirkel cirkel3 = new Cirkel(125); System.out.println("De oppervlakte van de cirkel met straal " + cirkel3.straal + " is " + cirkel3.berekenOppervlakte()); // Verander de straal van de tweede cirkel cirkel2.straal = 100; // of cirkel2.setStraal(100) System.out.println("De oppervlakte van de cirkel met straal " + cirkel2.straal + " is " + cirkel2.berekenOppervlakte()); } } // Definieer de klasse Cirkel class Cirkel { double straal; /** Constructor voor het maken van objecten met straal 1 */ Cirkel() { straal = 1; } /** Constructor voor het maken van objecten met opgegeven straal */ Cirkel(double nieuweStraal) { straal = nieuweStraal; } /** Bereken de oppervlakte van de cirkel en geeft het resultaat */ double berekenOppervlakte() { return straal * straal * Math.PI; } /** Bereken de omtrek van de cirkel */ double berekenOmtrek() { return 2 * straal * Math.PI; } /** Verander de straal van de cirkel */ void setStraal(double nieuweStraal) { straal = nieuweStraal; } }
  • Het bovenstaand programma bevat twee klassen. De eerste klasse TestCirkel is de main klasse. Het doel van die klasse is om de tweede klasse Cirkel te testen. Wanneer we het programma zal starten, dan zal Java de main-methode aanroepen.
  • Je kan twee klassen in één java-bestand plaatsen, maar slechts één klasse kan een public class zijn. Bovendien moet de naam van de public class dezelfde zijn als de naam van het java-bestand. Dus bovenstaand programma kan je in een java-bestand plaatsen met de naam TestCirkel.java en niet in Cirkel.java. De compilatie van TestCirkel.java zal resulteren in twee bestanden TestCirkel.class en Cirkel.class.
  • Het getuigt van een goede praktijk om het programma met de main-methode en de klasse (bv. Cirkel) te scheiden in twee verschillende betanden: TestCirkel.java en Cirkel.java.

Maken van objecten door het gebruik van constructoren

Een constructor wordt aangeroepen wanneer een object moet gemaakt worden door middel van de new operator

  • Constructoren zijn speciale methodes. Ze hebben 3 eigneschappen:
    • Een constructor moet exact dezelfde naam hebben als de klasse zelf (rekening houdend met de hoofdletters)
    • Een constructor heeft geen retourtype - zelfs niet void
    • Constructoren worden aangeroepen met de new operator wanneer een object moet gemaakt worden. Constructoren spelen dus een grote rol in het initializeren van objecten en de gegevensvelden van die objecten.
  • De naam van de constructor is exact hetzelfde als de naam van de klasse. Zoals andere methodes kunnen constructoren overladen worden, dus kunnen we meerdere constructoren definiëren met verschillende signaturen. Op deze manier kunnen we objecten maken met verschillende beginwaarden voor de gegevensvelden.
  • Constructoren worden gebruikt om objecten te maken. Om een object te maken vanuit een klasse, moeten we new operator gebruiken als volgt:
  new KlasseNaam(argumenten);
  • Bijvoorbeeld, new Cirkel() maakt een object van de klasse Cirkel door de eerste constructor in bovenstaande codevoorbeeld aan te roepen. new Cirkel(25) gebruikt de tweede constructor.
  • Een klasse voorziet normaal gezien een constructor zonder argumenten (bv. Cirkel()). Een dergelijke constructor wordt ook wel de no-arg of no-argumentconstructor genoemd.
  • Een klasse kan gedefinieerd worden zonder constructoren. In dat geval wordt een no-argument constructor met een lege body impliciet aangemaakt. Deze constructor noemen we de default constructor en wordt enkel maar voorzien als en slechts als er geen andere constructor expliciet gedefinieerd is.

Objecten aanspreken via referentievariabelen

De gegegevensvelden en methodes van een object kunnen aangeroepen worden door de punt (.) operator via de referentievariabele

Referentievariabelen en referentie types

  • Nieuwe objecten worden in het geheugen aangemaakt en kunnen we aanspreken via een referentievariabele. Die referentievariabele bevat een verwijzing naar het object. Dergelijke variabelen worden gedeclareerd als volgt:
  KlasseNaam objectReferentieVariabele;
  • Een klasse is in essentie een type die door de programmeur kan bepaald worden. Een klasse is een referentie type, dat betekent dat een variabele van die klasse type kan wijzen naar een object van die klasse. De volgende uitdrukking bepaalt een variabele mijnCirkel van het type Cirkel.
  Cirkel mijnCirkel;
  • De variabele mijnCirkel kan verwijzen naar een Cirkel object. De volgende uitdrukking maken we een Cirkel object en kennen we de verwijzing naar dit object toe aan mijnCirkel.
  mijnCirkel = new Cirkel();

  • We kunnen ook één uitdrukking gebruiken om

    1. een referentievariabele te declareren,
    2. een object te maken door de constructor aan te roepen en
    3. een verwijzing naar het gemaakte object toe te kennen aan de referentievariabelen

    In het algemeen wordt dit:

  KlasseNaam objectReferentieVariabele = new KlasseNaam();
  • Bijvoorbeeld met het de klasse Cirkel wordt dit:
  Cirkel mijnCirkel = new Cirkel();
  • Opmerking: Een referentievariabele van een object bevat eigenlijk een verwijzing naar het object. Strikt genomen is de referentievariabele en het object zelf totaal verschillend, meer meestal wordt dit verschil genegeerd. Hierdoor gaan we voor de eenvoud zeggen dat mijnCirkel een object is van de klasse Cirkel. Eerder dan steeds te vermelden dat mijnCirkel een referentie/verwijzing is naar het object Cirkel, wat zeer omslachtig is.
  • Opmerking: Arrays worden beschouwd als objecten in Java. Arrays moeten dus gemaakt worden door middel van de new operator.

Gegevensvelden en methodes van een object aanspreken

  • In OOP, kunnen we gegevensvelden van objecten aanspreken (opvragen of veranderen) of methodes van objecten aanroepen. Wanneer een object gemaakt is, kunnen we de gegevensvelden en methodes aanspreken met de punt operator (.). In het Engels ook wel object member access operator genoemd.

    • objectReferentieVariabele.gegevensVeld verwijst naar een gegevensveld in het object
    • objectReferentieVariabele.methode(argumenten) roept de methode aan die in de klasse van het object beschreven staat

  • Bijvoorbeeld, mijnCirkel.straal verwijst naar de straal van het object mijnCirkel en mijnCirkel.berekenOppervlakte roept de methode berekenOppervlakte aan op het object mijnCirkel. Methodes worden aangeroepen als bewerkingen op het object.

  • Opgelet: Herinner je dat je methodes van de Math klasse kan aanroepen door Math.methodeNaam(argumenten) (bv. Math.pow(3,2.5)). Kan je de methode berekenOppervlakte() en berekenOmtrek() ook op die manier aanroepen (dus als Cirkel.berekenOppervlakte() of Cirkel.berekenOmtrek())? Het antwoord is nee. Alle methodes in de klasse Math zijn zogenaamde statische methodes. Dit zijn methodes die je kunt aanroepen zonder dat je een object moet maken. Voor een machtsverheffing (Math.pow) of het genereren van een willekeurig getal (Math.random()), heb je geen object nodig. Maar voor het berekenen van een oppervlakte of omtrek hebben we de straal nodig die gedefinieerd is in de gegevensvelden van het object mijnCirkel. Dus voor instanties moeten we de naamvan het object gebruiken om die methodes te kunnen aanroepen. Dus, mijnCirkel.berekenOppervlakte() en mijnCirkel.berekenOmtrek().

Gegevensvelden die verwijzingen bevatten en de waarde null

  • De gegevensvelden van objecten kunnen ook andere objecten zijn. De types van deze gegevensvelden worden dan referentietypes genoemd. Bijvoorbeeld, een klasse Student bevat een gegevensveld naam dat een object is van de klasse String. String is een vooraf gedefinieerd klasse in Java.
class Student{ String naam; // naam heeft de defaultwaarde null int leeftijd; // leeftijd heeft de defaultwaarde 0 boolean isBachelorStudent; // isBachelorStudent heeft de defaultwaarde false char geslacht; // geslacht heeft de defaultwaarde '\u0000' }
  • Als een gegevensveld een object bevat van een klasse (en dus een referentietype bevat), dan heeft het gegevensveld de waarde null bij de initializatie. null is een literal voor een verwijzing naar een object als die verwijzing nog niet toegekend is.
  • Bij het maken van objecten kent Java initiële waarden toe voor de gegevensvelden: null voor een object van een andere klasse, 0 voor een type dat een getal bevat (int, double), false voor boolean en \u0000 voor het type char.

Referentietypes versus Primitieve types

  • Voor elke variabele in een programma wordt een geheugenlocatie aangemaakt. Wanneer je een variabele declareert, dan zeg je aan de compiler welk type de variabele heeft en dus hoeveel geheugen er moet vrij gehouden worden om waardes op die locatie te bewaren. Een variabele dat gedeclareerd is als een primitief type, dan bevat deze ook een waarde van het primitieve type.
Een variabele van een primitief type bevat een waarde van het primitieve type. Een variabele van een referentietype bevatten referentie (verwijzingen) naar een object in het geheugen
Figuur - Een variabele van een primitief type bevat een waarde van het primitieve type. Een variabele van een referentietype bevatten referentie (verwijzingen) naar een object in het geheugen
  • Wanneer je één variabele toekent aan een andere variabele, dan bevat die andere variabele dezelfde waarde. Als je de waarde van een referentievariable aan een andere referentievariabele dan wordt de referentie toegekend aan die andere variabele.
Boven: de waarde van een primitieve variabele wordt gekopieerd naar een andere; Onder: De referentie van variabele c2 wordt gekopieerd naar c1
Figuur - Boven: de waarde van een primitieve variabele wordt gekopieerd naar een andere; Onder: De referentie van variabele c2 wordt gekopieerd naar c1
  • Merk op: als we in bovenstaande figuur c1 = c2, dan wijst c1 naar het object waarnaar c2 verwijst. Het object naar waartoe c1 oorspronkelijke verwees is niet meer bruikbaar en het is daarom aanzien als afval of garbage. Garbage neemt plaats in het geheugen die we niet meer kunnen gebruiken. Java voorziet daarom een mechanisme om geheugen dat niet meer gebruikt wordt terug vrij te geven. Dit is gekend als garbage collection.

Statische variabelen, Constanten en Methodes

een statische variabele wordt gedeeld door alle objecten van een klasse. Een statische methode heeft geen toegang tot de gegevensvelden of methodes van een klasse.

  • Beschouw de klasse Cirkel. Een object van die klasse heeft een gegevensveld straal en is ook gekend als een intantievariabele. Een instantievariabele is gebonden aan een specifieke instantie van die klasse en de inhoud van de instantievariabele kan niet gedeeld worden met ander objecten. Bijvoorbeeld: beschouw het volgend stuk code
Cirkel cirkel1 = new Cirkel(); Cirkel cirkle2 = new Cirkel(5);
  • De straal in cirkel1 is volledig onafhankelijk van de straal in cirkel2 en wordt opgeslaan op een verschillende geheugenlocatie. Wanneer de waarde van straal in het object cirkel1 verandert, dan wordt de waarde van straal in het object cirkel2 niet meeverandert.

  • Indien je informatie wil delen over alle objecten in een bepaalde kasse, dan kan je statische variabelen gebruiken (ook wel klassevariabelen genoemd). Statische variabelen slaan waardes op voor variabelen in een gemeenschappelijk stuk geheugen. Daarom als je de waarde van een statische variabele verandert in een object van een klasse (bv. cirkel1) dan verandert die waarde ook in andere objecten (bv. cirkel2). Statische methodes zijn methodes die kunnen aangeroepen worden zonder dat je een object van de klasse moet aanmaken.

  • Stel dat we de klasse Cirkel willen aanpassen zodat we het aantal gemaakte objecten willen bijhouden. We kunnen dit doen met een statische variabele aantalObjecten. Wanneer een eerste object gemaakt wordt dan wordt aantalObjecten gelijk aan 1. Bij een volgend object, wordt dit 2.

class Cirkel{ /** de straal van de cirkel */ double straal; /** Het aantal gemaakte objecten */ static int aantalObjecten = 0; /** Constructor voor het maken van cirkel objecten met straal 1 */ Cirkel(){ straal = 1; aantalObjecten++; } /** Constructor voor het maken van cirkel objecten met straal 1 */ Cirkel(double nieuweStraal){ straal = nieuweStraal; aantalObjecten++; } } public class TestCirkelmetStatischeVariabelen{ /** Main methode */ public static void main(String[] args){ System.out.println("Voor het maken van objecten"); System.out.println("Het aantal Cirkel objecten is " + Cirkel.aantalObjecten); // Maak c1 Cirkel c1 = new Cirkel(); // Toon informatie System.out.println("Na het maken van c1"); System.out.println("c1 : straal (" + c1.straal + ") en het aantal objecten (" + c1.aantalObjecten + ")"); // Maak c2 Cirkel c2 = new Cirkel(5); // Toon informatie System.out.println("Na het maken van c2"); System.out.println("c1 : straal (" + c1.straal + ") en het aantal objecten (" + c1.aantalObjecten + ")"); System.out.println("c1 : straal (" + c2.straal + ") en het aantal objecten (" + c2.aantalObjecten + ")"); } }

Toegangsniveaus van gegevensvariabelen en methodes

Toegangsniveaus worden gebruikt om de toegang van een klasse, zijn gegevensvariabelen en zijn methodes te beperken

  • Je kan het toegangsniveau public gebruiken om aan te duiden dat een gegevensveld of methode kan worden opgevraagd of uitgevoerd door een andere klasse. Als er geen toegangsniveau wordt meegegeven dan zijn automatisch de gegevensvariabelen en methodes public.
  • Naast public, voorziet Java ook nog private en protected. protected wordt gebruikt bij overerving en zal besproken worden in Hoofdstuk 3.
  • Het toegangsniveau private maakt methodes en gegevensvariabelen enkel toegankelijk binnen de eigen klasse.
  • Onderstaand voorbeeld illustreert het gebruik van private, public en default toegangsniveau's.

Bestand: C1.java

public class C1{ public int x; int y; private int z; public void m1(){ } void m2(){ } private void m3(){ } }

Bestand: C2.java

public class C2{ void eenMethode(){ C1 c1 = new C1(); c1.x; // werkt, want x is public c1.y; // werkt, want y is default (public) c1.z; // werkt niet, want z is private (dit geeft een compileerfout) c1.m1(); // methode kan aangeroepen worden, want m1 is public c1.m2(); // methode kan aangeroepen worden, want m2 is default c1.m3(); // methode kan niet worden aangeroepen, methode m3 is private } }
  • Een object heeft toegang tot private gegevensvariabelen en methodes als ze gedefinieerd zijn in dezelfde klasse. Bv:

Bestand: C.java

public class C{ private boolean x; public static void main(String[] args){ C c = new C(); System.out.println(c.x); System.out.println(c.converteer()); } private int converteer(){ return x ? 1 : -1; } }

Encapsulatie van gegevensvelden

Het is goed om gegevensvariabelen private te declareren, zodat de klasse gemakkelijk te onderhouden is

  • In ons voorbeeld van de klasse Cirkel konden we toegang krijgen tot de velden straal en aantalObjecten op een heel directe manier via c1.straal en c1.aantalObjecten. Dit is geen goede manier van werken, omdat:
    • gegevens kunnen aangepast worden, zodat ze verkeerde informatie kunnen bevatten.
    • de klasse heel moeilijk te onderhouden wordt en kwetsbaar wordt voor fouten. Veronderstel dat je de klasse Cirkel wil aanpassen zodat je wil verzekeren dat het gegevensveld straal een niet-negatief getal bevat. Dan moet je niet alleen de klasse Cirkel aanpassen maar ook de programma's die gebruik maken van de klasse Cirkel en die de straal direct aanpassen (bv. c1.straal = -5).
  • Om dergelijke fouten te voorkomen, moeten we de gegevensvelden allemaal voorzien van private. Dit staat in Object Georiënteerd programmeren bekend als encapsulatie.
  • Een private gegevensvariabele kan niet opgevraagd worden door een object buiten de klasse. Toch moet het mogelijk zijn om waarden van die gegevensvariabelen te gebruiken in andere klasses. Om toegang te verkrijgen tot de waarde van een private gegevensveld, maken we gebruik van een getter methode. Een getter methode is ook wel gekend als een accessor wordt in het algemeen als volgt gedefinieerd:
  public retourtype getGegevensVariabele()
  • Om de waarde van een private gegevensvariabele te veranderen, gebruiken we een setter methode. Een setter methode is ook welk gekend als een mutator en wordt als volgt gedefinieerd:
  public void setGegevensVariabele(dataType nieuweWaarde)
  • Bijvoorbeeld voor de gegegevensvariabele straal van de klasse Cirkel wordt dit

Cirkel.java

public class Cirkel{ /** gegevensvariabele */ private double straal; /** Constructor met gegeven straal */ public Cirkel(double nieuweStraal){ straal = nieuweStraal; } /** getter methode */ public double getStraal(){ return straal; } /** setter methode */ public void setStraal(double nieuweStraal){ if(nieuweStraal >= 0){ straal = nieuweStraal; } else { straal =0; } } }

TestCirkel.java

public class TestCirkel{ /** Main methode */ public static void main(String[] args){ // Maak een cirkel met straal 5.0 Cirkel cirkel = new Cirkel(5.0); System.out.println("De oppervlakte van de cirkel met straal " + cirkel.getStraal() + " is " + cirkel.berekenOppervlakte()); // Verander de straal naar 6.0 cirkel.setStraal(6.0); System.out.println("De oppervlakte van de cirkel met straal " + cirkel.getStraal() + " is " + cirkel.berekenOppervlakte()); // Verhoog de straal met 10% cirkel.setStraal(cirkel.getStraal() * 1.1); System.out.println("De oppervlakte van de cirkel met straal " + cirkel.getStraal() + " is " + cirkel.berekenOppervlakte()); } }

Objecten als argumenten meegeven aan methodes

Een object meegeven als argument bij een methode is hetzelfde als het meegeven van de referentie van het objectReferentieVariabele

  • Het is mogelijk om objecten mee te geven met methodes, maar men er rekening mee houden dat je in feite de referentie of verwijzing doorgeeft aan de methode. Bijvoorbeeld:
public class Test{ public static void main(String[] args){ Cirkel cirkel1 = new Cirkel(5.0); printCirkel(cirkel1); } public static void printCirkel(Cirkel c){ System.out.println("De oppervlakte van de cirkel met straal " + c.getStraal() + " is " + c.berekenOppervlakte()); } }

Arrays van objecten

Een array kan ook objecten bevatten als ook waarden van primitieve types

  • Het is mogelijk om arrays van objecten te definiëren. Bv. het volgend stukje code maakt een array van 10 Cirkel objecten.
Cirkel[] cirkelArray = new Cirkel[10];
  • Dit maakt enkel de array, bij elk element van de array moeten nog de objecten van Cirkel gemaakt worden:
for (int i = 0; i < cirkelArray.length; i++){ cirkelArray[i] = new Cirkel(); }
  • De array bevat in feite referenties naar de objecten. Dus arrays van objecten zijn in feite 2 types van referenties. cirkelArray is een referentie naar een array object en een element van cirkelArray (bv. cirkelArray[0]) is een referentie naar een Cirkel object.

De this referentie

Het sleutelwoord this verwijst naar het object zelf. Het kan gebruikt worden in een constructor om een andere constructor aan te roepen.

  • Het sleutelwoord this is de naam van een referentie dat wijst naar het object waarin het sleutelwoord gebruikt wordt. Het sleutelwoord kan ook gebruikt woorden om te verwijzen naar gegevensvariabelen en methodes van het object.
public class Cirkel{ private double straal; public double berekenOppervlakte(){ return this.straal * this.straal * Math.PI; } public String toString(){ return "straal: " + this.straal + " oppervlakte: " + this.berekenOppervlakte(); } }

is equivalent met

public class Cirkel{ private double straal; public double berekenOppervlakte(){ return straal * straal * Math.PI; } public String toString(){ return "straal: " + straal + " oppervlakte: " + berekenOppervlakte(); } }
  • Het is een goede manier om gegevenvariabelen als parameternaam te gebruiken in een setter methode of een constructor. Hierdoor wordt de code leesbaarder en vermijden we het onnodig gebruik veel namen. Bv. de setStraal methode kan als volgt geïmplementeerd worden:
private double straal; public void setStraal(double straal){ this.straal = straal; }
  • In de toekenning this.straal = straal wordt via this in het linkerlid gerefereerd naar de gegevensvariabele, terwijl de straal in het rechterlid verwijst naar het argument van de methode setStraal.
  • Een variabele die static gedeclareerd is kunnen we niet refereren via this en moeten we de naam van klasse gebruiken: bv. KlasseNaam.staticVariabele.
public class F{ private int i; private static double k = 0; public void setI(int i){ this.i = i; } public static void setK(double k){ F.k = k; // en niet this.k !! } }
  • We kunnen this ook gebruiken om een constructor aan te roepen. Het sleutelwoord this wordt gebruikt om een andere constructor aan te roepen binnen dezelfde klasse. De onderstaande code, toont een constructer zonder argumenten (no-argument constructor) om een cirkle met maken met straal gelijk aan 1.0.
public class Cirkel{ private double straal; public Cirkel(double straal){ this.straal = straal; } public Cirkel(){ this(1.0); } }
  • Let op! Java vereist dat een constructor aanroep via this voor alle andere uitdrukkingen staat binnen de constructor.

results matching ""

    No results matching ""