Java-klassen en objecten

Een klasse definieert een type: de gegevens die de objecten onthouden en de bewerkingen die ze aanbieden. Een object, ook wel een instantie genoemd, is één waarde van dat type die wordt gemaakt terwijl een programma draait. Als je een klassedefinitie schrijft, maak je daarmee nog geen object.

Toestand en gedrag

De naam, diersoort en leeftijd van een huisdier vormen samen de toestand. Die huidige waarden staan in instantievariabelen, ook wel velden genoemd. Een bewerking zoals een verjaardag vieren is gedrag, geschreven als een methode. De verjaardagsmethode hoort bij de leeftijd die ze wijzigt, zodat de regel op één plek staat.

Zie een klasse als een bouwplan. Veel huizen kunnen volgens één plan worden gebouwd, maar elk huis heeft zijn eigen inhoud. Zo kunnen ook twee huisdieren dezelfde definitie volgen en verschillende leeftijden hebben. Je schrijft de veldnamen één keer; elk object krijgt zijn eigen waarden.

Lees een kleine klasse

public class Pet {
    private String name;
    private String species;
    private int age;

    public Pet(String name, String species, int age) {
        this.name = name;
        this.species = species;
        this.age = age;
    }

    public void celebrateBirthday() {
        this.age++;
    }
}

Lees dit van buiten naar binnen. public class Pet introduceert het type en de buitenste accolades bevatten de definitie ervan. De eerste drie declaraties beschrijven de toestand. Het blok met de naam Pet is een constructor: die geeft een nieuw object zijn eerste waarden. celebrateBirthday is een methode: die verhoogt de leeftijd van het huidige object. De woorden private en public regelen de toegang; latere voorbeelden gebruiken ze om de toestand te beschermen.

De parameters van de constructor zijn waarden die worden meegegeven wanneer een object wordt gemaakt. In this.age = age; duidt de linkerkant het veld van het object aan en de rechterkant de meegegeven parameter. De constructor slaat die invoer op, zodat het object die kan onthouden nadat de constructie is voltooid.

Gebruik een klasse

Je hebt al bibliotheekklassen gebruikt. Scanner beschrijft objecten die invoer lezen, ArrayList beschrijft lijsten en een String-object biedt bewerkingen zoals length(). Een klasse die je zelf schrijft volgt hetzelfde basisidee: ze stelt een bruikbaar type beschikbaar aan de rest van je programma.

Zonder Pet zou een programma een naam, diersoort en leeftijd misschien afzonderlijk aan veel methoden doorgeven. Het moet elke groep correct bij elkaar houden. Een Pet-object bevat de samenhangende waarden als één geheel. Methoden op dat object weten welke leeftijd ze moeten gebruiken.

Orden en benoem de code

Bij gewone bronbestanden wordt een publieke klasse met de naam Pet opgeslagen in Pet.java, met dezelfde hoofdletters. Een afzonderlijke klasse Main kan de main-methode van het programma bevatten, huisdieren maken en hun methoden aanroepen. Pet heeft zelf geen main nodig. Klassen in hetzelfde naamloze pakket kunnen elkaar zonder imports gebruiken; in de eenvoudige voorbeelden staan die klassen in één map.

Gebruik zelfstandige naamwoorden in UpperCamelCase voor klassen, zoals LibraryBook. Gebruik lowerCamelCase voor velden en methoden: pageCount benoemt gegevens; giveBack() benoemt een actie. Dit zijn conventies die een lezer helpen elk onderdeel te herkennen, ook al staat de compiler veel andere namen toe.

Een object maken en een variabele declareren zijn verschillende bewerkingen. Een variabele geeft je een naam waarmee je een object kunt bereiken; new maakt het object waarnaar de naam zal verwijzen.

Lees een instructie die een object maakt

Pet luna = new Pet("Luna", "cat", 3);

Pet is het type van de variabele en luna is de naam. new Pet(...) maakt een nieuw object en roept een passende constructor aan met drie argumenten. De constructor slaat de naam, diersoort en leeftijd op. De resulterende referentie wordt toegewezen aan luna.

Een referentie vertelt Java welk object moet worden gebruikt. Het is handig om een variabele te tekenen als een naam met een pijl naar een object. De variabele is geen tweede kopie van alle velden van het object.

Roep een methode aan op een bepaald object

De punt in luna.celebrateBirthday() verbindt een referentie met een methode die op het bijbehorende object wordt uitgevoerd. Een methode die iets teruggeeft, kan een waarde leveren aan een andere expressie:

luna.celebrateBirthday();
int years = luna.getAge();
System.out.println(years); // 4

Hier is getAge() een publieke methode die de leeftijd van het huisdier teruggeeft. De verjaardagsaanroep verandert de toestand; de getter leest die toestand. Pet.celebrateBirthday() werkt niet, omdat deze instantiemethode een bepaald huisdier nodig heeft. De klassenaam alleen geeft geen antwoord op de vraag wiens verjaardag het is.

Afzonderlijke objecten en gedeelde referenties

Pet max = new Pet("Max", "dog", 5);
luna.celebrateBirthday();
System.out.println(luna.getAge()); // 5
System.out.println(max.getAge());  // 5

Luna was al 4, dus door de volgende verjaardag wordt Luna 5. Max blijft 5. Gelijke leeftijden maken ze niet tot hetzelfde object: de twee new-expressies hebben afzonderlijke huisdieren gemaakt.

Bekijk nu een toewijzing zonder new:

Pet other = luna;
other.celebrateBirthday();
System.out.println(luna.getAge()); // 6

De toewijzing kopieert de referentie naar Luna. Beide namen verwijzen naar één huisdier, dus een wijziging via other is zichtbaar via luna. Roep new opnieuw aan om een tweede huisdier te maken.

Laat de argumenten passen bij de parameters van de constructor

Argumenten moeten passen bij het aantal, de volgorde en de typen van de parameters van een gedeclareerde constructor. Als de enige beschikbare constructor (String, String, int) verwacht, compileert new Pet() niet. Java raadt ontbrekende waarden niet. Als je de twee strings verwisselt, compileert de code echter wel: new Pet("cat", "Luna", 3) levert de juiste typen, maar de verkeerde betekenissen. Lees de parameternamen om de volgorde te controleren.

Deze twee onvoltooide pogingen mislukken om verschillende redenen:

Pet a;                         // declaration only
// System.out.println(a.getAge()); // a has no assigned value
// Pet b = Pet("Bo", "cat", 2);    // missing new

Aan een lokale variabele moet een waarde zijn toegewezen voordat je die gebruikt. Zonder new zoekt Java naar een methode met de naam Pet, niet naar een expressie die een object maakt. Zodra een object bestaat, kan het weergeven ervan tekst zoals Pet@8bcc55f opleveren totdat je een leesbare toString()-methode schrijft; die uitvoer betekent niet dat de constructie is mislukt.

Een object heeft een veld nodig voor elke waarde die het tussen methodeaanroepen moet onthouden. Kies die waarden voordat je methoden schrijft: ze vormen de blijvende toestand van het object.

Declareer velden met geschikte typen

Een veld staat binnen de accolades van de klasse, maar buiten alle constructoren en methoden. Een declaratie heeft een type en een naam nodig; er kunnen ook een toegangsmodifier en een initialisatiewaarde in staan.

private String title;
private int pageCount;
private boolean lentOut = false;

String is geschikt voor tekst, int voor een geheel aantal en boolean voor een ja-neetoestand. Velden kunnen ook klassetypen gebruiken, zoals ArrayList<String>. Deze voorbeelden gebruiken private; als je de modifier weglaat, krijg je pakkettoegang, geen private toegang.

Elk object krijgt een afzonderlijke kopie van elk instantieveld. Twee Rectangle-objecten hebben elk een width en een height, ook al staan de declaraties maar één keer in de klasse.

Standaardwaarden zijn niet altijd bruikbare beginwaarden

Een veld krijgt een standaardwaarde wanneer opslagruimte voor het object wordt gemaakt. Die waarde past mogelijk niet bij het doel van het object. Een lijstveld met de waarde null is geen lege lijst: je moet de lijst nog maken voordat je een element kunt toevoegen.

Lokale variabelen krijgen niet zo’n standaardwaarde. Binnen een methode compileert int total; gevolgd door System.out.println(total); niet, omdat aan total geen waarde is toegewezen. Houd de regel voor velden en de regel voor lokale variabelen uit elkaar.

Bepaal wat moet blijven bestaan

Een veld blijft bij het object. Een parameter is beschikbaar tijdens de bijbehorende aanroep en een lokale variabele is beschikbaar in het bijbehorende blok zolang die aanroep loopt. Als een teller zijn stand van de ene aanroep tot de volgende moet behouden, hoort die stand in een veld. Een tijdelijk subtotaal voor één berekening kan lokaal zijn.

Sla de invoer op; bereken afgeleide waarden

public class Rectangle {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return this.width * this.height;
    }
}

De afmetingen zijn in centimeters, dus area() geeft een oppervlakte in vierkante centimeters terug. Als je een apart veld voor de oppervlakte zou opslaan, ontstaat er nog een waarde die moet worden bijgewerkt wanneer een van de afmetingen verandert. Door de oppervlakte uit de afmetingen te berekenen blijft het antwoord consistent.

Gebruik een instantieveld met final voor een waarde die één keer wordt toegewezen, zoals private final String title;. Geef het veld een waarde in de declaratie of in elke constructor. final voorkomt hertoewijzing. static heeft een andere betekenis: het maakt één gedeeld klasseveld. Als je static toevoegt aan de naam van een huisdier, delen verschillende huisdieren één naamvariabele.

Een constructor initialiseert een object wanneer new het maakt. De naam moet overeenkomen met de klassenaam en de constructor heeft geen retourtype. Zelfs void zou de declaratie tot een methode maken.

Zet invoer om in toestand

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

Een constructor ontvangt invoer meestal als parameters en slaat die op in velden. Hier heeft elke parameter dezelfde naam als het bijbehorende veld. De naam age zonder toevoeging betekent de parameter; this.age betekent het veld van het object dat wordt gemaakt. De toewijzing leest de meegegeven waarde rechts en schrijft die naar het veld links.

Bij new Pet("Luna", "cat", 3) krijgen de velden van het nieuwe object eerst standaardwaarden: null, null en 0. De constructor ontvangt vervolgens de drie argumenten en vervangt die standaardwaarden. Wanneer de constructie is voltooid, levert new de referentie op die de aanroeper opslaat.

Twee fouten die compileren

public Pet(String name, String species, int age) {
    name = name;
    this.species = species;
    this.age = age;
}

Beide keren verwijst name naar de parameter, dus de eerste regel wijst die parameter aan zichzelf toe. De naam van het object blijft null. De code is geldig en daarom is het belangrijk de waarden van het nieuwe object te controleren.

Een declaratie binnen de constructor veroorzaakt een verwant probleem:

String nick = initialNick;

Als er al een veld met de naam nick bestaat, maakt deze regel een lokale variabele met dezelfde naam. De lokale variabele verdwijnt wanneer de constructie eindigt. Schrijf this.nick = initialNick; om de invoer in het veld op te slaan; herhaal het type niet.

Weet wanneer er een constructor zonder parameters bestaat

Als een klasse geen constructoren declareert, levert Java een standaardconstructor zonder parameters. Bij een eenvoudige klasse behouden de velden hun gedeclareerde initialisatiewaarden of standaardwaarden. Zodra je zelf een constructor declareert, levert Java die standaardconstructor niet meer.

Een klasse met alleen Pet(String name, String species, int age) kan daarom niet worden gemaakt met new Pet(). Voeg alleen een expliciete constructor zonder parameters toe wanneer daarvoor een bruikbare begintoestand bestaat. Let ook op public void Pet(...): dat is een methode en levert dus helemaal niet de bedoelde constructor op.

Stel ook interne beginwaarden in

Niet elk veld hoeft uit een argument te komen. Een nieuw boek kan altijd beginnen met this.lentOut = false;. Een klasse die een lijst beheert, kan die zo initialiseren, met ArrayList geïmporteerd:

private ArrayList<String> tracks;

public Playlist() {
    this.tracks = new ArrayList<>();
}

De lege lijst is klaar voor add. Als tracks op null blijft staan, mislukt een latere tracks.add(...) met NullPointerException.

Een veldinitialisator wordt vóór de constructorbody uitgevoerd. Als private int score = 10; wordt gevolgd door this.score = 5; in de constructor, is de score van het voltooide object 5. Test de waarden na de constructie, niet alleen de waarden die naast de velddeclaraties staan. Constructoren hebben ook dezelfde validatieregels nodig als latere wijzigingen, zodat de begintoestand geldig is.

Een klasse kan meerdere bruikbare manieren aanbieden om een object te maken. Constructoren overladen betekent dat je constructoren met verschillende parameterlijsten declareert.

Onderscheid constructoren op basis van parameters

Java onderscheidt constructoren op basis van het aantal, de typen en de volgorde van hun parameters. Parameternamen maken geen onderscheid. Box(String label) en Box(String name) beschrijven dezelfde parameterlijst, dus ze kunnen niet allebei in één klasse worden gedeclareerd.

Een huisdier kan worden gemaakt met een leeftijd of als pasgeboren dier:

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

public Pet(String name, String species) {
    this(name, species, 0);
}

new Pet("Pip", "rabbit") selecteert de constructor met twee parameters. Die constructor geeft 0 als ontbrekende leeftijd mee en roept de constructor met drie parameters aan. Het nieuwe object eindigt met de toestand "Pip", "rabbit" en 0.

Keten de initialisatie van hetzelfde object

Binnen een constructor roept this(...) een andere constructor van dezelfde klasse aan. De kortere constructor kiest standaardwaarden; de uitgebreidere constructor voert de gedeelde initialisatie uit. Controles in die initialisatie gelden voor beide constructieroutes.

Vergelijk twee regels die op elkaar lijken:

De tweede regel vult de velden van het huidige object niet. Als het resultaat nooit wordt opgeslagen, wordt dat extra huisdier weggegooid. Het huidige huisdier kan nog steeds velden met null hebben.

Volg een keten voordat je latere code doorloopt

Een klok kan middernacht als standaardwaarde aanbieden:

public Clock() {
    this(0, 0);
}

public Clock(int hours, int minutes) {
    this.hours = hours;
    this.minutes = minutes;
}

Voor new Clock() ga je naar de constructor zonder parameters, volg je this(0, 0) en wijs je beide velden toe in de constructor met twee parameters. Daarna keert de uitvoering terug naar de constructor zonder parameters. Dit maakt één klok, geen twee. Een aanroep van new Clock(9, 5) begint rechtstreeks in de uitgebreidere constructor.

Houd de keten geldig en duidelijk

Een constructor kan maximaal één aanroep van this(...) bevatten. De keten moet uiteindelijk een initialisatie bereiken die niet terug de keten in aanroept: twee constructoren die aan elkaar delegeren, veroorzaken tijdens het compileren een fout voor een recursieve constructoraanroep.

this(...) vooropzetten is een duidelijke stijl die in verschillende Java-versies werkt. In Java 24 en eerder zonder previewfuncties moet de aanroep vooropstaan. Java 25 staat voorafgaande instructies toe voor taken zoals het berekenen of controleren van argumenten. Die instructies mogen geen instantievelden van het huidige object lezen of instantiemethoden ervan aanroepen; toewijzingen aan velden die in de klasse zijn gedeclareerd zonder initialisatiewaarde in de declaratie zijn toegestaan.

Bied overladen constructoren aan omdat aanroepers verschillende bruikbare invoer hebben. Een klok die op middernacht begint is zinvol; een boek zonder titel misschien niet. Het bestaan van een volledige constructor maakt niet automatisch kortere overladen varianten.

Een instantiemethode wordt uitgevoerd voor één bepaald object. Declareer de methode zonder static en gebruik velden van dat object via namen zoals this.width. Bepaal wat de aanroeper nodig heeft: een toestandswijziging, een teruggegeven resultaat of beide.

Geef berekeningen terug; maak toestandswijzigingen expliciet

Voor een rechthoek waarvan de afmetingen in centimeters zijn opgeslagen:

public double area() {
    return this.width * this.height;
}

public double perimeter() {
    return 2 * (this.width + this.height);
}

public void scale(double factor) {
    this.width = this.width * factor;
    this.height = this.height * factor;
}

Een rechthoek met zijden van 3,0 en 4,0 heeft een oppervlakte van 12,0 vierkante centimeter en een omtrek van 14,0 centimeter. scale(2) verandert de zijden in 6,0 en 8,0. De volgende aanroepen geven oppervlakte 48,0 en omtrek 28,0 terug. Elke methode leest de huidige velden, dus er hoeft geen opgeslagen oppervlakte te worden bijgewerkt.

area() geeft een getal terug dat kan worden opgeslagen of in een berekening kan worden gebruikt. Als de methode het getal alleen zou weergeven en retourtype void zou hebben, zou de aanroeper niet double twice = r.area() * 2; kunnen schrijven. Laat de weergave aan de aanroeper over wanneer een methode als taak heeft een waarde te berekenen.

Werk samenhangende velden in volgorde bij

De methode advance() van een klok moet zowel de overgang van de minuten als die van de uren afhandelen:

public void advance() {
    this.minutes++;
    if (this.minutes == 60) {
        this.minutes = 0;
        this.hours++;
        if (this.hours == 24) {
            this.hours = 0;
        }
    }
}

Om 23.58 uur bereikt de eerste aanroep 23.59 uur en slaat beide blokken voor het terugzetten over. De volgende aanroep bereikt kortstondig minuut 60, zet die terug naar 0, verhoogt het uur naar 24 en zet dat terug naar 0. De uiteindelijke toestand is 00.00 uur. Nog één aanroep geeft 00.01 uur.

Volg objecten afzonderlijk

Schrijf na elke instructie een rij en maak een kolom voor de velden van elk object. Wijzig alleen het object dat de ontvanger van de aanroep aanduidt. Bij huisdieren van 2 en 7 jaar leiden twee verjaardagen van het eerste huisdier en setAge(1) op het tweede tot leeftijden van 4 en 1. Voer de body van een methode niet voor elke instantie uit alleen omdat ze een klasse delen.

Een lokale declaratie kan het veld afschermen dat je wilde bijwerken. public void reset() { int count = 0; } maakt alleen een tijdelijke variabele. this.count = 0; zet de blijvende tellerstand terug.

Hergebruik methoden en maak retourpaden compleet

Binnen een instantiemethode roepen area() en this.area() de oppervlaktemethode van hetzelfde object aan. Een beschrijvingsmethode kan die berekening hergebruiken in plaats van de expressie te kopiëren. Een methode kan ook de toestand wijzigen en teruggeven of dat is gelukt, zoals lend() doet wanneer die een boek als uitgeleend markeert en true meldt.

Een methode met een ander retourtype dan void kan niet zomaar het einde bereiken zonder een passende waarde terug te geven. Als get() alleen binnen if (count > 0) iets teruggeeft, wat gebeurt er dan wanneer de tellerstand 0 is? Voeg het ontbrekende retourpad toe of werp een exceptie op voor een waarde die de methode afwijst. Een pad dat een exceptie opwerpt, keert niet terug naar de aanroeper en heeft geen retourwaarde nodig.

Vraag van wie een waarde of bewerking is voordat je beslist of je static gebruikt. De leeftijd van een huisdier hoort bij één huisdier. Een telling van alle gemaakte huisdieren hoort bij de klasse als geheel.

Het huidige object is this

Binnen een constructor of instantiemethode verwijst this naar het object dat wordt geconstrueerd of de aanroep ontvangt. In this.age++ geeft het aan wiens leeftijd verandert. In this.name = name onderscheidt het het veld van een parameter met dezelfde naam. this(...) is de vorm waarmee je constructoren ketent.

Een statische methode heeft geen huidig object, dus this kan daar niet worden gebruikt. De methode kan nog steeds een object maken of een referentie ontvangen en die referentie gebruiken om instantiemethoden aan te roepen.

Gedeelde velden en velden per object

public class Counter {
    private int count;
    private static int created = 0;

    public Counter() {
        this.count = 0;
        created++;
    }

    public void increment() {
        this.count++;
    }

    public int getCount() {
        return this.count;
    }

    public static int getCreated() {
        return created;
    }
}

Na twee aanroepen van new Counter() zijn er twee afzonderlijke count-velden, die beide aanvankelijk 0 zijn, en één created-veld met waarde 2. Als je de eerste teller verhoogt, verandert de stand daarvan in 1; de tweede blijft 0. Counter.getCreated() geeft nog steeds 2 terug omdat er geen nieuw object is geconstrueerd.

Werk vanuit main via een object

public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    System.out.println(c.getCount());
}

De klassieke main-methode is statisch. Een aanroep van increment() met alleen de naam zou daar geen doelobject hebben en niet compileren. De variabele c levert dat doelobject. Als je count statisch zou maken om de fout te laten verdwijnen, zou het ontwerp veranderen: elke teller zou dan één tellerstand delen.

Java 25 ondersteunt ook instantievormen van main, maar de klassieke statische kop blijft geldig. Deze voorbeelden gebruiken die consequent.

Kies methoden en constanten bewust

Een bewerking die de velden van een object nodig heeft, moet een instantiemethode zijn. Een bewerking die alleen van haar parameters afhangt, kan statisch zijn, zoals een hulpmethode die een totaal aantal minuten omzet naar uren. Statische aanroepen gebruiken normaal gesproken de klassenaam: Math.sqrt(16) of Counter.getCreated().

Een gedeelde vaste waarde wordt meestal als constante gedeclareerd:

public static final int MAX_CELSIUS = 30;

public maakt de constante beschikbaar voor aanroepers, static geeft de klasse één gedeeld veld en final voorkomt hertoewijzing. UPPER_SNAKE_CASE duidt volgens afspraak een constante aan. Dit is een gebruikelijke uitzondering op het private maken van velden. Gebruik static niet voor gewone namen, afmetingen of een andere toestand die tussen objecten moet verschillen.

Encapsulatie houdt de toestand van een object samen met de code die die toestand beheert. Velden zijn meestal private, terwijl aanroepers publieke bewerkingen gebruiken. Dit schermt opslagdetails af en geeft de klasse een plek om haar regels af te dwingen.

Kies een toegangsniveau

Een pakket groepeert klassen. In de eenvoudige voorbeelden staan gewone klassen bij elkaar zonder een package-declaratie, in één naamloos pakket. Pakkettoegang ontstaat door de modifier weg te laten; er is geen toegangssleutelwoord package dat je aan een veld kunt toevoegen.

Begin met de meest beperkte bruikbare toegang. Maak velden private, constructoren en bewerkingen die andere klassen nodig hebben public en interne hulpmethoden private. Publieke constanten zijn een gebruikelijke uitzondering voor velden.

Laat de klasse wijzigingen beheren

Als Pet private int age; declareert, kan een afzonderlijke klasse Main niet luna.age = -5; toewijzen. De compiler wijst de toegang af. Een aanroep zoals luna.setAge(-5) kan wel worden toegestaan, omdat de publieke methode bij Pet hoort en kan beslissen of het argument wordt opgeslagen.

Met een public veld zou elke aanroeper die methode kunnen omzeilen. Zodra alle wijzigingen via de code van de klasse lopen, kunnen de controles op één plek staan. Private toegang alleen valideert een leeftijd niet; de methoden moeten de controles ook uitvoeren.

Houd de publieke interface stabiel

Stel dat een klok aanvankelijk afzonderlijke velden hours en minutes opslaat. Aanroepers gebruiken getHours() en getMinutes(). Later vervang je de velden door één waarde minutesSinceMidnight:

public int getHours() {
    return this.minutesSinceMidnight / 60;
}

public int getMinutes() {
    return this.minutesSinceMidnight % 60;
}

Met 615 opgeslagen minuten geeft de deling 10 terug en de restbewerking 15. De klok geeft via dezelfde methoden 10.15 uur aan. Aanroepers hoeven niet te worden herschreven omdat ze afhankelijk waren van de publieke bewerkingen, niet van de manier waarop de toestand werd opgeslagen. Deze vrijheid om de interne werking te wijzigen heet informatieafscherming.

Toegang hoort bij klassen, niet bij afzonderlijke objecten

Code binnen Pet kan een privéveld van een ander Pet-object lezen. De toegang volgt uit het feit dat de code binnen de klasse staat. Een andere klasse op het hoogste niveau krijgt geen toegang doordat die een referentie naar een huisdier heeft of in dezelfde map staat.

Voor gewone klassedeclaraties op het hoogste niveau zijn de toegangskeuzes public of geen modifier. Een private class Pet op het hoogste niveau is niet toegestaan. Een publieke klasse op het hoogste niveau hoort in het bijbehorende bronbestand en één gewoon bronbestand bevat maximaal één publieke klasse op het hoogste niveau.

Private velden vormen een grens in het programmaontwerp. Ze voorkomen dat andere gewone code rechtstreeks afhankelijk wordt van interne velden, maar zijn geen manier om een waarde geheim te houden voor iemand die het programma kan bekijken. Gebruik ze om de interface van je klasse te beheren en de toestand ervan te beschermen.

Een klasse kan aanroepers geselecteerde delen van haar toestand laten lezen of wijzigen via methoden. Bepaal welke bewerkingen de klasse moet aanbieden voordat je voor elk veld toegangsmethoden maakt.

Geef waarden terug met getters

Een getter, ook wel een accessor genoemd, geeft informatie terug zonder het object te wijzigen. Een gebruikelijke getter leest een veld:

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

Het retourtype past bij de informatie die wordt geleverd. Een getter die iets weergeeft en void teruggeeft, kan geen waarde leveren aan een expressie zoals pet.getAge() + 1. De aanroeper moet de waarde ontvangen en beslissen hoe die wordt gebruikt.

Wijzig geselecteerde waarden met setters

Een setter, ook wel een mutator genoemd, neemt een nieuwe waarde aan en werkt de toestand bij:

public void setName(String name) {
    this.name = name;
}

this.name is het veld. name is de parameter. Als je name = name; schrijft, compileert de code, maar verandert er geen veld. Er is hier geen retourwaarde omdat deze setter als taak heeft een wijziging uit te voeren.

Voor een huisdier van 3 jaar:

luna.setName("Lulu");
System.out.println(luna.getName() + " is " + luna.getAge());
// Lulu is 3

De aanroeper benadert een veld nooit rechtstreeks. De setter verandert de naam en de getters geven de huidige waarden terug zodat de aanroeper die kan combineren.

Volg de naamgeving die andere Java-code verwacht

Schrijf de eerste letter van de veldnaam als hoofdletter na get, set of het gebruikelijke booleaanse voorvoegsel is. Een naam zoals getname() kan compileren, maar volgt niet de conventie die hulpmiddelen en andere programmeurs verwachten.

Bied alleen bruikbare bewerkingen aan

De titel van een boek kan een getter hebben en geen setter, omdat aanroepers de titel wel mogen lezen maar niet vervangen. Een private final-veld kan afdwingen dat er één keer een waarde aan wordt toegewezen. Een interne teller heeft mogelijk geen getter en geen setter nodig als alleen de klasse die gebruikt.

Een setter zonder controle kan dezelfde schadelijke waarde accepteren als een public veld. Voeg controles toe waar een wijziging beperkingen heeft. Overweeg ook een actiemethode: celebrateBirthday() drukt uit dat de leeftijd met één wordt verhoogd en lend() drukt een uitleenpoging uit. lend() kan de huidige toestand bekijken en een tweede uitlening weigeren. Een setter kan die controle ook uitvoeren; de actienaam maakt de bewerking duidelijker voor de aanroeper.

Een getter kan een antwoord berekenen. getArea() kan het product van breedte en hoogte teruggeven zonder een veld area.

Een invariant is een regel voor de toestand van een object die geldt na de constructie en na elke publieke bewerking. Een thermostaat kan doeltemperaturen van 5 °C tot en met 30 °C toestaan. Elke manier om de doeltemperatuur in te stellen moet dat bereik respecteren.

Kies wat ongeldige invoer betekent

Drie bruikbare reacties zijn de oude waarde behouden, de waarde tot een grens begrenzen of een exceptie opwerpen. Ze hebben verschillende effecten, dus kies voor elke bewerking een duidelijke reactie.

Voor een niet-negatieve leeftijd van een huisdier kan een setter die ongeldige waarden negeert alleen binnen if (age >= 0) een waarde toewijzen. Als de opgeslagen leeftijd 4 is, laat setAge(-2) die op 4 staan. De leeftijd wordt niet 0.

Plaats bereikcontroles binnen de klasse

public static final int MIN_CELSIUS = 5;
public static final int MAX_CELSIUS = 30;
private int target;

public void setTarget(int celsius) {
    if (celsius < MIN_CELSIUS) {
        this.target = MIN_CELSIUS;
    } else if (celsius > MAX_CELSIUS) {
        this.target = MAX_CELSIUS;
    } else {
        this.target = celsius;
    }
}

public void raise() {
    setTarget(this.target + 1);
}

Beginnend bij 20 °C slaat setTarget(35) 30 op. setTarget(-3) slaat 5 op. Na setTarget(29) slaat een aanroep van raise() 30 op; een volgende aanroep slaat nog steeds 30 op. Door de setter te hergebruiken kan raise() de bovengrens niet overschrijden.

Controles in alleen Main kunnen de thermostaat niet beschermen. Een andere aanroeper zou ze kunnen vergeten. De klasse moet de invoer controleren op de plek waar ze de opslag beheert.

Valideer ook de begintoestand

public Thermostat(int target) {
    setTarget(target);
}

Met deze begrenzende constructor eindigt new Thermostat(50) op 30 °C. Door rechtstreeks this.target = target; toe te wijzen zou de ongeldige begintoestand 50 worden toegestaan. Een gedeelde private controlemethode is een andere manier om validatie in constructoren en latere methoden te hergebruiken.

Een exceptie opwerpen is nuttig wanneer een ongeldig argument op een programmeerfout wijst. Een constructor kan bijvoorbeeld een negatief aantal afwijzen met throw new IllegalArgumentException("count must not be negative");. Het object wordt niet succesvol geconstrueerd, dus de aanroeper krijgt geen ongeldig voltooid object. Invoer negeren is eenvoudiger maar gebeurt stilzwijgend; de aanroeper heeft mogelijk een andere manier nodig om te merken dat er niets is veranderd.

Houd veranderlijke interne gegevens binnen de klasse

Een private lijst kan nog steeds uitlekken als een getter de oorspronkelijke lijst teruggeeft. Een aanroeper zou dan elementen kunnen toevoegen of verwijderen zonder de methoden van de klasse te gebruiken en zo een regel voor de maximale grootte omzeilen.

Voor een ArrayList<String>-veld met de naam tracks geeft return new ArrayList<>(this.tracks); een afzonderlijke lijst met dezelfde strings terug. Als je die teruggegeven lijst wijzigt, verandert de interne lijst niet. Bewerkingen zoals addTrack(String title) kunnen lijstwijzigingen binnen de klasse houden en de regels controleren voordat ze wijzigingen accepteren.

Een bruikbaar object moet gemakkelijk als tekst te bekijken zijn. De ingebouwde Java-methode toString() geeft een klassenaam, een @-teken en een hexadecimale hashcode terug, zoals Pet@8bcc55f. Een benoemd pakket wordt onderdeel van de klassenaam. De hashtekst varieert en zegt meestal weinig over de toestand van het object.

Geef een leesbare beschrijving terug

@Override
public String toString() {
    return this.name + " (" + this.species + ", "
        + this.age + " years)";
}

Voor Luna, een kat van 3 jaar, is de teruggegeven string "Luna (cat, 3 years)". De methode leest velden en bouwt een string op. Ze verandert het huisdier niet en stuurt geen uitvoer naar het scherm.

@Override vraagt de compiler te controleren of de declaratie echt een bestaande methode vervangt. Dat ontdekt fouten zoals tostring schrijven met een kleine s. De annotatie maakt het resultaat niet voor je op; de retourwaarde wordt bepaald door de return-expressie.

Herken automatische aanroepen

System.out.println(luna);
String label = "Pet: " + luna;
String details = luna.toString();

De eerste regel geeft de leesbare beschrijving van het huisdier weer. De tweede bouwt "Pet: Luna (cat, 3 years)" op. De derde vraagt expliciet dezelfde beschrijving op en slaat die op zonder die weer te geven. Wanneer een ArrayList met huisdieren wordt weergegeven, gebruikt de weergave van de lijst de toString() van elk huisdier tussen de vierkante haken van de lijst.

Door de automatische omzetting is het belangrijk tekst terug te geven. De aanroeper kan het resultaat weergeven, opslaan of samenvoegen. Een methode die alleen iets weergeeft, kan niet de string leveren die al die aanroepers nodig hebben.

Laat de methodekop overeenkomen

Gebruik de exacte kop zonder parameters en voeg de annotatie toe. Een overladen methodevariant met parameters kan een geldige afzonderlijke methode zijn, maar bij het weergeven van een object worden die parameters niet meegegeven.

Maak waarden op zonder ze te veranderen

Een klok heeft uren en minuten met twee cijfers nodig. Binnen de methode toString():

return String.format(java.util.Locale.US,
    "%02d:%02d", this.hours, this.minutes);

Voor uren 9 en minuten 5 is de string "09:05". Elke %02d maakt een geheel getal op met minstens twee posities en gebruikt zo nodig een voorloopnul. String.format(java.util.Locale.US, "%.2f", 7.5) geeft "7.50" terug. Door de taal- en regio-instelling mee te geven is de uitvoer met een decimale punt onafhankelijk van de standaardinstelling voor opmaak van de computer.

Houd de beschrijving kort genoeg om te lezen tijdens het opsporen van fouten. Ze kan een niet-ingestelde toestand zichtbaar maken: als je een naamveld met null samenvoegt met een string, ontstaat de tekst "null", die je terugleidt naar de initialisatie. De beschrijving moet de huidige toestand melden, dus als je het object twee keer weergeeft, mag dat een klok niet vooruitzetten of een verjaardag vieren.

Begin met wat één object moet onthouden, wat aanroepers het kunnen laten doen en welke toestanden moeten zijn toegestaan. Zet daarna elk onderdeel om in velden, constructoren en methoden.

Haal het ontwerp uit een beschrijving

“Een bibliotheekboek heeft een titel, een auteur en een aantal pagina’s. Het kan worden uitgeleend en teruggebracht. Het kan niet opnieuw worden uitgeleend zolang het al is uitgeleend.”

Gebruik LibraryBook als klassenaam. Sla de drie beschrijvende waarden en een booleaanse uitleenstatus op. De titel, auteur en het aantal pagina’s blijven vast, dus maak ze final. De uitleenstatus verandert door betekenisvolle acties. Een setter voor elk veld is niet nodig.

Bouw de complete klasse

public class LibraryBook {
    private final String title;
    private final String author;
    private final int pages;
    private boolean lentOut;

    public LibraryBook(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.lentOut = false;
    }

    public boolean isLentOut() {
        return this.lentOut;
    }

    public boolean lend() {
        if (this.lentOut) {
            return false;
        }
        this.lentOut = true;
        return true;
    }

    public void giveBack() {
        this.lentOut = false;
    }

    @Override
    public String toString() {
        String status = this.lentOut ? "lent out" : "available";
        return this.title + " by " + this.author + ", "
            + this.pages + " pages, " + status;
    }
}

De constructor maakt het boek beschikbaar. lend() controleert de bestaande toestand voordat die verandert; door bij een tweede uitlening false terug te geven blijft de regel gehandhaafd. giveBack() maakt het boek beschikbaar. De getter meldt de status en toString() beschrijft het hele boek zonder het te veranderen.

Schrijf verwachtingen op voordat je aanroepen uitvoert

In de klassieke main-methode van een afzonderlijke klasse Main:

LibraryBook b = new LibraryBook("Night Train", "A. Rivera", 320);
System.out.println(b);        // Night Train by A. Rivera, 320 pages, available
System.out.println(b.lend()); // true
System.out.println(b.lend()); // false
b.giveBack();
System.out.println(b.lend()); // true

De tweede uitleenpoging is essentieel: een methode die altijd de vlag instelt en true teruggeeft, zou bij de eerste aanroep slagen maar niet bij deze controle. Test de retourwaarden en controleer ook de toestand met isLentOut(). Probeer ook een tweede boek om te controleren of het uitlenen van het ene boek het andere beschikbaar laat.

Test waar het gedrag verandert

Zorg dat je tests elke constructor en publieke methode dekken. Probeer bij bereikcontroles beide grenswaarden en waarden net daarbuiten. Controleer bij een klok de overgang van de minuten en de overgang naar middernacht. Controleer bij een setter die ongeldige invoer afwijst of negeert of die invoer het beloofde effect op de oude toestand heeft. Schrijf eerst het verwachte resultaat op, zodat onverwachte uitvoer niet ongemerkt je nieuwe verwachting wordt.

Bouw in kleine stappen: eerst velden en constructor, dan een leesbare beschrijving en daarna steeds één bewerking met de bijbehorende controles. Sla gewone publieke klassen op in bestanden met overeenkomstige namen, compileer ze samen en voer de klasse uit die main bevat. Door modelbewerkingen gescheiden te houden van schermuitvoer kan dezelfde klasse verschillende programma’s dienen.