Objecten, referenties en gelijkheid in Java

Een Java-variabele bevat een waarde. De belangrijke vraag is of die waarde een gewoon gegeven is of een referentie die naar een object leidt. In beide gevallen kopieert een toewijzing die waarde.

Primitieve gegevens en objectreferenties

Java heeft acht primitieve typen: byte, short, int, long, float, double, char en boolean. Een primitieve variabele bevat zijn gegevens rechtstreeks. Een referentievariabele bevat een referentie naar een object of de speciale waarde null. Klassen zoals String, Scanner en ArrayList, je eigen klassen en arrays zijn referentietypen.

In new Counter() maakt Java een object, voert de constructor ervan uit en levert een referentie op. De toewijzing slaat die referentie op in c. Teken de variabele als een doosje met een pijl naar een afzonderlijk object. Elke evaluatie van new maakt een afzonderlijk object, ook als de argumenten overeenkomen.

Kopieer de waarde en volg het resultaat

Bij primitieve waarden blijft de eerste variabele onaangeroerd als je de gekopieerde variabele wijzigt:

int a = 5;
int b = a;
b = b + 1;

De laatste regel leest 5 uit b, telt er 1 bij op en slaat 6 op in b. De waarde in a blijft 5.

Gebruik voor een voorbeeld met referenties deze kleine klasse:

class Counter {
    private int value;

    Counter() { this.value = 0; }
    Counter(int value) { this.value = value; }
    void increase() { value++; }
    int value() { return value; }
}

Volg nu deze instructies:

Counter first = new Counter();
Counter second = first;
second.increase();
System.out.println(first.value()); // 1

Alleen de eerste regel maakt een teller. De tweede regel kopieert de referentie, zodat de methodeaanroep de ene teller wijzigt die beide variabelen bereiken. Om een onafhankelijke teller met dezelfde gegevens te maken, schrijf je new Counter(first.value()). Het kopiëren van een variabele roept geen constructor aan.

Wrappers en onveranderlijke strings

Elk primitief type heeft een wrapperklasse, zoals Integer, Double, Boolean of Character. Wrappervariabelen bevatten referenties of null. Java kan een primitieve waarde en de bijbehorende wrapper automatisch in elkaar omzetten; deze conversies heten autoboxing en unboxing. Lijsten bevatten referenties, dus een lijst met gehele getallen is ArrayList<Integer>.

Ook String is een referentietype, maar de objecten ervan zijn onveranderlijk: hun tekens kunnen na het maken niet veranderen.

String s = "java";
String t = s;
t = t.toUpperCase();

Hier verwijst s nog steeds naar “java” en verwijst t naar “JAVA”. De laatste regel wijst het resultaat toe aan t; de toewijzing wijzigt de gedeelde oorspronkelijke string niet. String-methoden kunnen het oorspronkelijke object hergebruiken als er geen wijziging nodig is.

Het afdrukken van een object gebruikt de methode toString() ervan. Zonder overschrijving heeft het overgeërfde resultaat een vorm zoals Counter@7e9e5f8a: klassenaam, @ en een hexadecimale hashcode. Definieer toString() als de afgedrukte uitvoer de gegevens van het object moet tonen.

Twee variabelen die naar hetzelfde object verwijzen, zijn aliassen. Een alias biedt een andere route naar bestaande gegevens. Houd bij het volgen van een programma de variabelen gescheiden van de objecten die ze bereiken.

Mutatie wijzigt gegevens; hertoewijzing wijzigt een variabele

Een mutatie wijzigt de toestand van een object, zoals het opgeslagen gewicht. Een hertoewijzing plaatst een andere waarde in een variabele. Bij een referentievariabele verandert daardoor de pijl.

Gebruik een doos waarvan het gewicht in kilogram is:

class Box {
    private double weight;
    Box(double weight) { this.weight = weight; }
    double getWeight() { return weight; }
    void setWeight(double weight) { this.weight = weight; }
}

Volg deze reeks:

Box a = new Box(2);
Box b = a;
b.setWeight(5);
b = new Box(7);

1. Teken variabele a met een pijl naar object A, met gewicht 2.
2. Teken b met een pijl naar datzelfde object A. Er is nog steeds één doos.
3. Verander het gewicht in object A in 5. Beide routes bereiken nu gewicht 5.
4. Maak object B met gewicht 7 en richt alleen b daarop.

Aan het einde is a.getWeight() gelijk aan 5 en b.getWeight() gelijk aan 7. De vierde instructie zet object A niet terug en laat a ook niet naar object B verwijzen.

Bereikbaarheid bepaalt de levensduur van een object

Een object is bereikbaar zolang het draaiende programma een bruikbare keten van referenties ernaartoe kan volgen. Die keten kan via een variabele, een objectveld of een lijstelement lopen. Als een lokale variabele verdwijnt, is dat dus niet genoeg om een object onbereikbaar te maken als een lijst het nog bevat.

Ga verder met a = null;. Object A, dat 5 kg weegt, heeft in dit voorbeeld nu geen bereikbaar pad meer. Het komt in aanmerking voor automatische geheugenopruiming (garbage collection). Java maakt het geheugen van onbereikbare objecten automatisch vrij, maar de garbage collector kiest wanneer; de toewijzing garandeert geen onmiddellijke opruiming. Object B blijft bereikbaar via b.

Je geeft Java-objecten niet handmatig vrij. Als een programma zijn laatste bruikbare referentie naar een object verliest, verliest het ook de mogelijkheid om de gegevens van dat object te bekijken of te wijzigen.

Zoek de verborgen aliassen

Aliassen ontstaan wanneer een object aan een lijst wordt toegevoegd, aan een methode wordt doorgegeven, door een methode wordt teruggegeven of in een veld van een ander object wordt opgeslagen. Elke bewerking kan een referentie doorgeven. Ga voordat je een ontvangen object wijzigt na welke andere code het nog kan bereiken.

Een veelvoorkomende fout begint met de gedachte: “Ik heb de variabele gekopieerd, dus ik heb mijn eigen doos.” Gebruik een nieuw object als wijzigingen onafhankelijk moeten zijn. Om de fout op te sporen, tel je het maken van objecten afzonderlijk van toewijzingen, geef je elk object één keer een naam en verwerk je elke instructie op volgorde. Teken een object niet opnieuw alleen omdat een tweede variabele er nu naar wijst.

De waarde null betekent dat een referentie naar geen object leidt. Dat is nuttig voor een ontbrekend resultaat, maar een programma moet die afwezigheid afhandelen voordat het een object probeert te gebruiken.

Ontbrekend is iets anders dan leeg

String text = ""; verwijst naar een echte string met lengte 0. String text = null; verwijst naar geen string, dus er is geen object waarop je length() kunt aanroepen.

Een primitieve waarde kan geen null bevatten: int x = null; compileert niet. Een wrapper kan die waarde wel bevatten: Integer x = null; compileert. Als je die wrapper met int y = x; omzet naar een primitieve waarde, ontstaat een NullPointerException, omdat voor unboxing een wrapperobject nodig is.

Velden krijgen initiële standaardwaarden wanneer een object wordt gemaakt. Referentievelden beginnen als null, numerieke velden als 0 en booleaanse velden als false, totdat de initialisatie andere waarden toewijst. Lokale variabelen hebben geen standaardwaarde. Als je een lokale variabele leest voordat je er een waarde aan toewijst, ontstaat een compilatiefout, zoals “variable might not have been initialized”.

Zoek de ontbrekende referentie

Als je via null een instantiemethode aanroept, een instantieveld benadert of de lengte van een array leest, ontstaat tijdens de uitvoering een NullPointerException. Bijvoorbeeld:

String name = null;
System.out.println(name.length());

Lees het regelnummer van de exceptie en bepaal welke referentie op die regel ontbrak. Verhelderende meldingen zijn vanaf Java 15 standaard ingeschakeld. Een melding kan luiden: Cannot invoke "SimpleDate.getYear()" because "this.birthday" is null. Lokale namen kunnen verschijnen als plaatsaanduidingen zoals <local4>, afhankelijk van de manier van compileren. Ga terug naar de constructor, toewijzing of zoekactie die het object had moeten leveren.

Het afdrukken van een String-variabele met de waarde null drukt “null” af; concatenatie levert tekst op zoals “Hi null”. Voor deze bewerkingen hoeft geen instantiemethode via die variabele te worden aangeroepen. Ze kunnen ontbrekende gegevens zichtbaar maken voordat een latere methodeaanroep mislukt.

Controleer vóór gebruik

De operator && gebruikt kortsluitevaluatie: die evalueert de rechterkant alleen als de linkerkant waar is.

if (name != null && name.length() > 0) {
    System.out.println(name);
}

Als name gelijk is aan null, is de eerste test onwaar en wordt length() overgeslagen. Als je de twee tests omdraait, vervalt die bescherming: de methodeaanroep zou eerst worden uitgevoerd.

De vaste string is een bekend object, dus equals ervan kan null ontvangen en false teruggeven. command.equals("quit") mislukt als command null is. Evenzo is x.equals(null) geen manier om te controleren of x bestaat: de aanroep vereist al een object.

Maak afwezigheid een duidelijke ontwerpkeuze

Initialiseer een lijstveld met new ArrayList<>(), zodat meteen een lege collectie beschikbaar is. Als een zoekactie null teruggeeft voor “niet gevonden”, documenteer dat resultaat dan en controleer het op de plaats van de aanroep. Vul niet elk veld met willekeurige objecten alleen om een exceptie te voorkomen: lever het object dat het programma nodig heeft, of geef afwezigheid een duidelijke betekenis die de aanroepende code afhandelt.

Java geeft elk argument als waarde door. Een parameter is een nieuwe variabele die een kopie van de waarde van het argument ontvangt. Bij een objectargument is de gekopieerde waarde een referentie.

De parameter wijzigen of het object wijzigen?

Een primitieve parameter heeft zijn eigen gegevens:

static void addTen(int n) {
    n = n + 10;
}

Als x gelijk is aan 5, laat de aanroep addTen(x) de waarde van x op 5 staan. Alleen de lokale parameter n wordt 15.

Een referentieparameter kan hetzelfde object bereiken als de aanroeper. Stel dat Person.growOlder() de opgeslagen leeftijd verhoogt:

static void celebrate(Person p) {
    p.growOlder();
}

static void replace(Person p) {
    p = new Person("Bo", 30);
}

Tijdens celebrate(ana) zijn de parameter p en de variabele ana aliassen. De gewijzigde leeftijd blijft daarna zichtbaar. Tijdens replace(ana) richt de toewijzing aan p alleen die parameter ergens anders op. De variabele ana van de aanroeper blijft naar de oorspronkelijke persoon verwijzen. Een methode die twee referentieparameters verwisselt, heeft dezelfde beperking: de methode verwisselt de eigen kopieën, niet de variabelen van de aanroeper.

Een object van een andere klasse ontvangen

Een toegangspoort kan de lengte van een persoon lezen en zelf het aantal controles bijhouden. Deze klasse verwacht een persoon die niet null is en een methode getHeight() heeft die centimeters teruggeeft:

class HeightGate {
    private int minHeight;
    private int checks;

    HeightGate(int minHeight) {
        this.minHeight = minHeight;
    }

    boolean allowIn(Person p) {
        checks++;
        return p.getHeight() >= minHeight;
    }

    int checks() { return checks; }
}

Bij een poort die is ingesteld op 120 cm geven controles van personen van 132 cm en 115 cm respectievelijk true en false terug. De poort meldt daarna 2 controles. De poort leest de lengte van de persoon via een publieke methode en wijzigt de eigen teller.

Een ander object van dezelfde klasse ontvangen

Binnen SimpleDate.before(SimpleDate other) is this de datum waarop de methode wordt aangeroepen en is other het argument. Een klasse kan de private velden van elk object van dezelfde klasse lezen.

Vergelijk bij de velden day, month en year in deze volgorde:

boolean before(SimpleDate other) {
    if (year != other.year) {
        return year < other.year;
    }
    if (month != other.month) {
        return month < other.month;
    }
    return day < other.day;
}

Bij 14 maart 2001 en 2 november 2001 zijn de jaren gelijk en is maand 3 kleiner dan maand 11, dus de eerste datum is eerder. Gelijke datums geven false terug, omdat geen van beide vóór de andere ligt.

Person.olderThan(other) kan het werk delegeren aan birthday.before(other.birthday). De datumvergelijking hoort bij de datumgegevens. Methoden die instantiemethoden op een parameter aanroepen, hebben een argument nodig dat niet null is; controleer dat of vermeld die eis in de documentatie voor het gebruik van de methode.

Een methode die een object teruggeeft, geeft een referentie terug. Het type vertelt je welk soort object kan worden teruggegeven, maar niet of het object nieuw, gedeeld of afwezig is. Het doel van de methode moet die keuze duidelijk maken.

Maak een resultaat

Een fabrieksmethode levert een object. De methode kan er een maken of een bestaand object hergebruiken. Hier maakt elke aanroep bewust een afzonderlijk ticket:

class TicketMachine {
    private int nextNumber = 1;

    Ticket issue() {
        Ticket t = new Ticket(nextNumber);
        nextNumber++;
        return t;
    }
}

De automaat verwacht een Ticket-constructor die het nummer opslaat. Drie aanroepen maken drie tickets met de nummers 1, 2 en 3. Een lokale variabele teruggeven is veilig: de referentie wordt gekopieerd naar de aanroeper, die het object bereikbaar kan houden nadat de lokale variabele buiten bereik is geraakt.

Een kopieermethode belooft een onafhankelijk object. In de klasse Counter:

Counter copy() {
    return new Counter(this.value);
}

Na Counter a = new Counter(4); Counter b = a.copy(); b.increase(); is a.value() gelijk aan 4 en b.value() gelijk aan 5. Als je a.copy() vervangt door a, wordt de teller gedeeld.

Een methode kan ook een berekend object maken. Voor een Point met double-velden x en y:

Point midpoint(Point other) {
    return new Point((x + other.x) / 2.0,
                     (y + other.y) / 2.0);
}

De punten (2, 4) en (6, 10) geven (4,0; 7,0). De methode berekent elke coördinaat en geeft beide door aan een nieuw punt; geen van beide oorspronkelijke punten verandert.

Geef een al opgeslagen object terug

De methode findByName van een register moet de overeenkomende opgeslagen persoon teruggeven als aanroepers met dat item moeten werken. Als je new Person(name, 0) maakt, geef je verzonnen vervangende gegevens terug en hebben latere wijzigingen geen invloed op het register.

Een zoekactie kan null teruggeven als er geen overeenkomst is:

Person p = register.findByName("Lin");
if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Not found");
}

Als p de opgeslagen persoon is, wijzigen veranderingen via p ook de persoon die via het register wordt bereikt. Een return-instructie kopieert het object niet.

Houd veranderlijke interne toestand onder controle

Stel dat Person.getBirthday() het veld SimpleDate teruggeeft en dat die datum setters heeft. Een aanroeper kan dan de geboortedatum van de persoon wijzigen zonder een methode van Person aan te roepen. Dit is het prijsgeven van veranderlijke toestand.

Om het veld te beschermen, geef je een nieuwe datum terug die is opgebouwd uit de waarden ervan:

SimpleDate getBirthday() {
    return new SimpleDate(birthday.getDay(),
                          birthday.getMonth(),
                          birthday.getYear());
}

Deze versie vereist dat een geboortedatumobject is geïnitialiseerd. Andere ontwerpen gebruiken een onveranderlijke datum of bieden specifieke zoekmethoden zonder een datumgetter. Kies het gedrag voor elke methode: find deelt normaal gesproken een opgeslagen item, terwijl copy onafhankelijkheid creëert. De korte naam van een getter alleen garandeert geen bescherming.

Compositie bouwt een klasse op met velden waarvan de typen andere klassen zijn. Daarmee druk je een relatie van het type “heeft een” uit: een persoon heeft een geboortedatum; een cursus heeft een docent. Het buitenste object slaat een referentie naar het opgenomen object op.

Maak en verbind de objecten

Een constructor kan een bestaande datum ontvangen:

class Person {
    private String name;
    private SimpleDate birthday;

    Person(String name, SimpleDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    boolean olderThan(Person other) {
        return birthday.before(other.birthday);
    }

    public String toString() {
        return name + ", born " + birthday;
    }
}

De aanroep new Person("Ana", new SimpleDate(14, 3, 2001)) maakt eerst een datum en geeft de referentie daarna aan de persoon. Een constructor voor een persoon kan ook dag, maand en jaar ontvangen en de datum binnen zijn body maken. Bij die aanpak behoudt de aanroeper geen referentie naar de nieuw gemaakte datum.

Delegeer werk aan het opgenomen object

De aanroep birthday.before(other.birthday) vraagt het datumobject om datums te vergelijken. Person hoeft de vergelijkingen van jaar, maand en dag niet te herhalen. Concatenatie in toString() delegeert ook: Java roept toString() van het geboortedatumobject aan om de tekst ervan te verkrijgen.

Een datumobject kan helpen de leeftijd te berekenen. Begin met het huidige jaar min het geboortejaar. Stel daarna de verjaardag van dit jaar samen en trek er één af als de huidige datum daarvoor ligt. Een persoon die op 14 maart 2001 is geboren, is op 1 januari 2026 24: het verschil tussen de jaren is 25, maar de verjaardag is nog niet geweest. Op 14 maart 2026 is de verjaardag geweest en is de leeftijd 25. Door de datumvergelijking in SimpleDate te houden, hoef je de regels ervan niet in elke methode voor personen te herhalen.

Bepaal of het binnenste object wordt gedeeld

De constructor hierboven slaat het argument rechtstreeks op. Als twee personen één veranderlijke SimpleDate ontvangen, wijzen beide geboortedatumvelden naar dezelfde datum. Een wijziging van die datum heeft invloed op beide personen.

Een defensieve constructor kan de dag, maand en het jaar van de ontvangen datum kopiëren. Een onveranderlijke datum heeft geen methoden die de toestand wijzigen en houdt de waarden vast; eenvoudige primitieve velden kunnen final zijn. Kopiëren bij invoer is ook belangrijk als een getter later een kopie teruggeeft, omdat de oorspronkelijke aanroeper het ontvangen object nog kan hebben.

Handel optionele verbindingen af

Een Course heeft mogelijk nog geen docent. Als dat een betekenisvolle toestand is, kan teacherName() het veld controleren en “nog geen docent” teruggeven. Vereis anders een docent bij het maken van het object.

In course.getTeacher().getName() heeft elke instantieaanroep een object nodig: een cursus die null is, mislukt bij getTeacher() en een docent die null is, mislukt bij getName(). Een methode op de cursus kan die controle op afwezigheid op één plek houden, zodat niet elke aanroeper dezelfde keten hoeft te kennen.

Een ArrayList<Person> is een object waarvan de elementen referenties naar personen bevatten. De lijst beheert de volgorde van de items; elke persoon beheert zijn eigen velden. Dit zijn verschillende soorten wijzigingen.

Voeg een object toe en bereik het opnieuw

ArrayList<Person> people = new ArrayList<>();
people.add(ana);
people.get(0).growOlder();

Deze code heeft import java.util.ArrayList; nodig en een bestaande persoon ana die niet null is. add kopieert de referentie. De aanroep growOlder() bereikt dezelfde persoon als ana, dus de leeftijdswijziging is via beide routes zichtbaar. De lijst maakt hier geen tweede persoon.

Je kunt een object maken terwijl je het toevoegt: people.add(new Person("Lin", 1998));, met een constructor voor een persoon die een naam en geboortejaar accepteert. De lijst biedt het programma dan een route naar die nieuwe persoon via get of een lus. Typeargumenten van lijsten moeten referentietypen zijn, dus gebruik ArrayList<Integer> voor gehele getallen.

Bereken met objecten en selecteer een object

Stel dat een lijst pakketten bevat met gewichten van 2,5 kg; 4,0 kg en 1,5 kg. Een lus telt het gewicht van elk pakket op:

double total = 0;
for (Parcel p : parcels) {
    total += p.getWeight();
}

De lopende totalen zijn 2,5; 6,5 en 8,0 kg. Voor het selecteren van het zwaarste pakket zijn zowel een referentie als een vergelijking nodig:

Parcel heaviest = parcels.get(0);
for (Parcel p : parcels) {
    if (p.getWeight() > heaviest.getWeight()) {
        heaviest = p;
    }
}

Deze selectie verwacht een niet-lege lijst. Het resultaat is het pakketobject van 4,0 kg, zodat de aanroeper ook de andere methoden ervan kan gebruiken. Bepaal bij een lege lijst wat het ontbrekende resultaat is voordat je element 0 leest.

Doorzoek elk item

Een zoekactie op naam in een klasse die people opslaat, kan het volgende gebruiken:

Person findByName(String name) {
    for (Person p : people) {
        if (p.getName().equals(name)) {
            return p;
        }
    }
    return null;
}

Deze versie verwacht personen die niet null zijn en namen hebben die niet null zijn. De eerste overeenkomst wordt direct teruggegeven. De laatste return null hoort na de lus: een mislukte vergelijking bij de eerste persoon sluit latere overeenkomsten niet uit.

contains, indexOf en remove(Object) zoeken met equals. Als Person gelijkheid op basis van identiteit erft, komt een nieuw gemaakte persoon niet overeen met een bestaande persoon alleen omdat de velden overeenkomen.

Verwijder een item zonder een object te vernietigen

Eén object kan twee keer in één lijst of in meerdere lijsten voorkomen. Als je een item verwijdert, vernietig je het object niet en verwijder je ook geen andere referenties ernaar.

Verwijder tijdens een for-each-lus geen items rechtstreeks uit dezelfde lijst. Dat kan een ConcurrentModificationException veroorzaken. Verzamel eerst de te verwijderen items en verwijder ze daarna:

ArrayList<Person> toRemove = new ArrayList<>();
for (Person p : people) {
    if (p.getName().equals("Lin")) {
        toRemove.add(p);
    }
}
people.removeAll(toRemove);

De lus is klaar voordat de lijstinhoud verandert. removeAll gebruikt gelijkheid en verwijdert dus items die gelijk zijn aan de verzamelde items.

Een klasse kan een lijst in een privaat veld bewaren en bewerkingen aanbieden die het doel ervan beschrijven. Een afspeellijst slaat nummers op, telt ze en berekent de duur. Aanroepers zouden de lijst niet rechtstreeks hoeven te beheren.

Initialiseer de collectie en scherm die af

Deze afspeellijst verwacht Song-objecten die niet null zijn en een methode seconds() hebben:

import java.util.ArrayList;

class Playlist {
    private String name;
    private ArrayList<Song> songs;

    Playlist(String name) {
        this.name = name;
        this.songs = new ArrayList<>();
    }

    void add(Song song) { songs.add(song); }
    int count() { return songs.size(); }

    int totalSeconds() {
        int total = 0;
        for (Song song : songs) {
            total += song.seconds();
        }
        return total;
    }
}

Zonder new ArrayList<>() blijft het referentieveld null; de eerste aanroep van add mislukt dan. Een lege lijst is al een bruikbaar object, met grootte 0.

Voor nummers van 210 s, 185 s en 247 s geeft count() 3 terug. Het totaal groeit van 210 naar 395 naar 642 s. Geheeltallige deling door 60 geeft 10 minuten, met rest 42 seconden. Een methode longest() kan het nummer van 247 s selecteren en teruggeven, met hetzelfde patroon voor het selecteren van een referentie als bij het zwaarste pakket. Definieer een ontbrekend resultaat voor een lege afspeellijst.

Bescherm de lijstinhoud met methoden

Als je songs private houdt, blokkeer je directe toegang tot het veld, maar return songs; geeft juist die lijst prijs. Een aanroeper zou clear() kunnen aanroepen en elke regel van de afspeellijst kunnen omzeilen.

Specifieke bewerkingen zoals add, count en totalSeconds houden de verantwoordelijkheid bij de afspeellijst. De methode add kan een maximumgrootte handhaven of duplicaten weigeren met songs.contains(song). Voor controles op duplicaten op basis van inhoud moet equals van de nummerklasse bepalen welke velden twee nummers gelijk maken.

Als een constructor een beginlijst ontvangt, kopieer je de structuur met this.songs = new ArrayList<>(initialSongs);. Als je de parameter rechtstreeks zou opslaan, zou de aanroeper een alias naar de interne lijst van de afspeellijst kunnen behouden.

Een nieuwe lijst kan nog steeds nummers delen

Een zoekmethode kan new ArrayList<>(songs) teruggeven. Dit is een ondiepe kopie: een nieuw lijstobject dat de bestaande referenties naar nummers bevat.

Een zoekmethode songsLongerThan(200) maakt een nieuwe resultaatlijst, doorloopt de opgeslagen nummers en voegt de nummers toe waarvan de duur langer is dan 200 s. Voor de drie nummers hierboven geeft de methode de nummers van 210 s en 247 s terug. Als ook de waarden van de nummers onafhankelijk moeten zijn, kopieer dan de veranderlijke nummers of maak Song onveranderlijk.

Identiteit gaat over de vraag of twee referenties naar hetzelfde object leiden. Inhoudelijke gelijkheid gaat over de vraag of objecten dezelfde relevante gegevens hebben, volgens de regels van de klasse. Twee afzonderlijke boekobjecten kunnen dezelfde titel en hetzelfde publicatiejaar beschrijven zonder identiek te zijn.

Kies de juiste vergelijking

Elke klasse erft equals(Object) van Object. Die standaardversie controleert identiteit. Java onderzoekt niet automatisch alle velden van een nieuwe klasse.

String a = "java";
String b = new String("java");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

new String maakt een afzonderlijk object, terwijl String.equals de tekens vergelijkt. Tekstvergelijking is hoofdlettergevoelig: "Java".equals("java") is false. equalsIgnoreCase vergelijkt zonder onderscheid tussen hoofdletters en kleine letters wanneer dat de bedoelde regel is.

Waarom identiteit soms inhoud lijkt te vergelijken

Gelijke stringliterals delen een stringobject, dus "java" == "java" is true. Daardoor kan een fout in een kleine test verborgen blijven. Tekst uit invoer of tekst die tijdens de uitvoering van een programma wordt opgebouwd, hoeft dat object niet te delen. Gebruik equals voor de inhoud, ongeacht hoe de tekst is verkregen.

Bij wrappervergelijkingen bestaat een vergelijkbare valkuil:

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c.equals(d)); // true

Autoboxing hergebruikt Integer-objecten voor waarden van -128 tot en met 127. Of grotere waarden een object delen, is geen overdraagbare regel voor getalvergelijking. Bij een standaardconfiguratie zijn de twee wrappers voor 1000 afzonderlijk, maar een grotere cache is toegestaan. Gebruik equals van de wrapper voor overeenkomende wrapperwaarden of vergelijk primitieve waarden. Als één kant van == een int is, pakt Java de wrapper uit en vergelijkt het de numerieke waarden; het uitpakken van een null-wrapper mislukt.

Bepaal welke velden gelijkheid bepalen

Voor een boekencatalogus kunnen titel en publicatiejaar de gelijkheid bepalen, terwijl de huidige lener wordt genegeerd. Die gekozen velden moeten de gelijkheidsmethode bepalen. Een ander programma kan in plaats daarvan een unieke identificator kiezen; welke regel bruikbaar is, hangt af van wat de objecten voorstellen.

Een ArrayList gebruikt equals in contains, indexOf en remove(Object). Stel dat Book alleen velden opslaat en equals erft. Als je één new Book("Dune", 1965) toevoegt, wordt contains(new Book("Dune", 1965)) niet true: de tweede expressie maakt een ander object. Door gelijkheid op titel en jaar te baseren, kan een zoekactie die gelijke inhoud vinden.

HashSet en HashMap gebruiken ook hashCode om de mogelijke objecten te beperken voordat ze gelijkheid controleren. Inhoudelijke gelijkheid definiëren vereist daarom ook een passende regel voor hashcodes.

Een gelijkheidsmethode moet de overgeërfde methode equals(Object) vervangen en de velden vergelijken die de betekenis van je object bepalen. De juiste signatuur is net zo belangrijk als de vergelijkingen binnen de methode.

Een volledig patroon voor gelijkheid

Deze klasse gebruikt titel en jaar, staat een titel met de waarde null toe en houdt de velden voor gelijkheidsbepaling vast:

import java.util.Objects;

final class Book {
    private final String title;
    private final int year;

    Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Book)) {
            return false;
        }
        Book book = (Book) other;
        return year == book.year
            && Objects.equals(title, book.title);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, year);
    }
}

Lees equals in vier stappen. De identiteitscontrole accepteert hetzelfde object direct. De typecontrole weigert alles wat geen boek is, inclusief null. De cast levert een Book-variabele op waarmee de velden kunnen worden gelezen. De laatste expressie controleert beide velden voor gelijkheidsbepaling.

Het parametertype is Object, niet Book. Als je equals(Book other) schrijft, overlaad je de naam met een andere methode en laat je de overgeërfde equals(Object) ongewijzigd. Een directe aanroep kan dan lijken te werken, terwijl ArrayList.contains nog steeds identiteit gebruikt. Met @Override laat je de compiler die fout in de signatuur ontdekken.

Vanaf Java 16 kun je de typecontrole en cast combineren: if (!(other instanceof Book book)) { return false; }. Nadat de controle is geslaagd, is book beschikbaar om velden te vergelijken.

Stem vergelijkingen af op veldtypen

Gebruik == voor velden met gehele getallen, tekens en booleaanse waarden. Gebruik equals van een object voor de inhoud. Voor een objectveld dat null kan zijn, geeft Objects.equals(a, b) true terug als beide null zijn, false als slechts één null is en gebruikt de methode anders gelijkheid.

Voor double-velden zorgt Double.compare(x, other.x) == 0 voor een consistente behandeling van speciale waarden: twee NaN-waarden worden als gelijk beschouwd en positieve en negatieve nul worden onderscheiden. Combineer die keuze met een bijpassende hashcoderegel. Een directe vergelijking van zwevendekommagetallen met == behandelt NaN anders.

Controleer het gelijkheidscontract

Voor referenties die niet null zijn, moet gelijkheid zijn:

• Reflexief: x.equals(x) is true.
• Symmetrisch: x.equals(y) en y.equals(x) komen overeen.
• Transitief: als x gelijk is aan y en y gelijk is aan z, is x gelijk aan z.
• Consistent: herhaalde aanroepen komen overeen zolang de vergeleken gegevens ongewijzigd blijven.
• False voor null: x.equals(null) is false.

Twee boeken voor “Dune”, 1965 zijn bij vergelijking gelijk; als je één jaar verandert in 1984, zijn ze ongelijk. Een boek mag bij vergelijking niet gelijk zijn aan een string met de titel: de string zou het boek weigeren, waardoor de symmetrie wordt verbroken.

Sommige implementaties gebruiken other == null || getClass() != other.getClass() voor de typecontrole. Die controle weigert verschillende werkelijke klassen. instanceof kan subklassen accepteren; voor de final-klasse hierboven bestaat geen subklasse en komen de twee controles overeen.

Een hashcode is een geheel getal dat wordt gebruikt om een zoekactie te beperken. HashSet en HashMap gebruiken de hashcode om mogelijke objecten te vinden en gebruiken daarna equals om een overeenkomst te bevestigen. Een hashcode is geen unieke objectidentificator.

Het contract geldt in één richting

Gelijke objecten moeten dezelfde hashcode teruggeven. Ongelijke objecten mogen ook een code delen; dat is een hashbotsing. Een botsing maakt de objecten niet gelijk, omdat gelijkheid nog steeds wordt gecontroleerd.

Een hashcode moet consistent blijven zolang de informatie die equals gebruikt ongewijzigd blijft. Bij een correcte implementatie sluiten verschillende hashcodes gelijkheid uit, maar bewijzen gelijke hashcodes geen gelijkheid.

Als een klasse equals overschrijft maar Object.hashCode erft, krijgen afzonderlijke gelijke objecten vaak verschillende codes. Een verzameling kan dan beide bewaren en een zoekactie in een map met een nieuwe gelijke sleutel kan niets vinden. De precieze fout is niet gegarandeerd, omdat verschillende objecten dezelfde overgeërfde code kunnen krijgen. Herstel het contract in plaats van te vertrouwen op een specifieke mislukte zoekactie.

Bereken de hashcode uit de velden voor gelijkheidsbepaling

Voor de boekklasse die titel en jaar vergelijkt:

@Override
public int hashCode() {
    return Objects.hash(title, year);
}

Importeer java.util.Objects. Dezelfde veldwaarden leveren nu hetzelfde resultaat op. Een verzameling boeken bevat één item nadat twee gelijke boeken zijn toegevoegd en een map kan een waarde ophalen met een nieuwe gelijke boeksleutel.

Objects.hash combineert de hashcodes van de velden met 31. Voor “Dune” is de stringhashcode 2.141.736. De combinatie van die titel en het jaar 1965 geeft 31 vermenigvuldigd met de som van 31 en 2.141.736, plus 1965: het resultaat is 66.396.742.

Ook bij het berekenen van stringhashcodes wordt 31 gebruikt. Voor “ab” geven de tekencodes 97 en 98: 97 vermenigvuldigd met 31 plus 98, oftewel 3105. Langere berekeningen kunnen het bereik van int overschrijden en overlopen, dus een negatieve hashcode is normaal.

Wijzig de sleutel niet tijdens opslag

Stel dat het jaar van een boek veranderlijk is en invloed heeft op de hashcode. Als je na toevoeging aan een verzameling het jaar wijzigt, kan contains(book) mislukken, zelfs met dezelfde referentie: de zoekactie zoekt nu met een andere code. De verzameling kan nog steeds grootte 1 melden.

Houd velden voor gelijkheidsbepaling stabiel zolang een object een element van een verzameling of een sleutel in een map is. Als ze moeten veranderen, verwijder dan het object terwijl de oude waarden nog gelden, wijzig het en voeg het opnieuw toe. Als je pas na de wijziging probeert te verwijderen, kun je hetzelfde zoekprobleem tegenkomen.

Ook bij gegenereerde gelijkheid moet je de gegevens zorgvuldig kiezen

Java 16 en later ondersteunen records, zoals record Book(String title, int year) {}. Een record genereert accessors title() en year(), plus gelijkheid, hashcodes en een leesbare stringvorm op basis van alle componenten. Componentvelden zijn final. Dit voorbeeld is een bruikbare onveranderlijke waarde omdat de componenten een string en een geheel getal zijn; een record met een veranderlijke lijst zou nog steeds de toestand van die lijst delen.

Voor gewone klassen kan een IDE equals en hashCode samen genereren. Selecteer de velden die de bedoelde gelijkheid bepalen en houd beide methoden op elkaar afgestemd als die keuze verandert.

De gebruikersinterface leest invoer en toont uitvoer. De programmalogica slaat gegevens op en past regels toe. In een ontwerp met gescheiden verantwoordelijkheden geef je waarden door aan de logica en krijg je resultaten terug; de klassen voor de logica gebruiken geen Scanner of System.out.

Verbind de objecten in main

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    TemperatureLog log = new TemperatureLog();
    UserInterface ui = new UserInterface(scanner, log);
    ui.start();
}

Met import java.util.Scanner; maakt deze samenstelling één invoerlezer, één logboek en één interface. De code hoort in de startklasse van het programma. UserInterface slaat de ontvangen objecten op in velden, zodat elke opdracht met hetzelfde logboek werkt.

Geef waarden terug die elke aanroeper kan gebruiken

Een logboek kan add(double celsius), count(), average() en max() aanbieden. Metingen van 18,5; 21,0 en 19,5 °C hebben een som van 59,0, een aantal van 3, een maximum van 21,0 en een gemiddelde van ongeveer 19,6667 °C. De gebruikersinterface kan het teruggegeven gemiddelde afronden met Math.round(average * 10) / 10.0 en 19,7 °C tonen.

Als de methode het getal teruggeeft, kun je het gemakkelijk rechtstreeks controleren. Een methode met de naam printAverage() die alleen afdrukt, koppelt een berekening aan console-uitvoer, waardoor hergebruik lastiger wordt.

Stel voor een eenvoudige opdrachtlus dat add geldige temperaturen accepteert en count het aantal teruggeeft:

class UserInterface {
    private Scanner scanner;
    private TemperatureLog log;

    UserInterface(Scanner scanner, TemperatureLog log) {
        this.scanner = scanner;
        this.log = log;
    }

    void start() {
        while (true) {
            String command = scanner.nextLine();
            if ("quit".equals(command)) {
                break;
            }
            if ("count".equals(command)) {
                System.out.println(log.count());
            }
        }
    }
}

De lus handelt de interactie af. De lus vraagt het logboek om een resultaat en drukt dat af zonder te weten hoe de metingen worden opgeslagen. Een opdracht voor het gemiddelde moet een leeg logboek afhandelen volgens het gedocumenteerde resultaat van de logica, of count() controleren voordat een methode wordt aangeroepen die metingen vereist.

Valideer op de juiste grens

De logica kan add false laten teruggeven zonder een meting onder -273,15 °C op te slaan. Elke aanroeper krijgt dan dezelfde gegevensregel. De gebruikersinterface bepaalt hoe die de weigering meldt en opnieuw om invoer vraagt. Ook niet-numerieke invoer omzetten in een bruikbare foutmelding is werk voor de interface.

Gebruik één Scanner voor System.in en geef die door aan de code die invoer leest. Meerdere scanners kunnen om gebufferde invoer concurreren en als je er één sluit, sluit je de onderliggende invoerstroom. Laat de code die de programma-invoer beheert ook de levensduur van de gedeelde scanner beheren.

De logica kan later via dezelfde publieke methoden een andere interface ondersteunen. Hergebruik ontstaat doordat berekeningen en geldigheidsregels als methoderesultaten beschikbaar blijven, onafhankelijk van een bepaalde opdrachtlus.

Een programma met gescheiden verantwoordelijkheden kan met kleine wijzigingen groeien. Geef de logica een bruikbare methode, controleer die rechtstreeks en verbind daarna een opdracht die de invoer verzamelt en het resultaat toont.

Voeg een zoekmethode toe aan de logica

Een TemperatureLog die een geïnitialiseerde ArrayList<Double> readings opslaat, kan metingen boven een grenswaarde tellen:

int countAbove(double limit) {
    int count = 0;
    for (double reading : readings) {
        if (reading > limit) {
            count++;
        }
    }
    return count;
}

De strikte vergelijking sluit metingen uit die precies gelijk zijn aan de grenswaarde. Voor 18,5; 21,0; 19,5 en 23,0 °C geeft countAbove(20.0) 2 terug. Plaats de vergelijking in het logboek, zodat elke aanroeper dezelfde regel krijgt.

De opdracht in de gebruikersinterface leest een grenswaarde, roept log.countAbove(limit) aan en drukt het aantal af. Als elke opdracht lang wordt, splits start() dan op in private hulpmethoden zoals addReading() en showStatistics(). De hulpmethoden organiseren de interactie; ze halen de gegevensregels niet uit het logboek.

Controleer zonder opdrachten te typen

Maak het object voor de logica en roep de methoden aan met waarden waarvan je de antwoorden kent:

TemperatureLog log = new TemperatureLog();
log.add(18.5);
log.add(21.0);
log.add(19.5);
log.add(23.0);
System.out.println(log.count() == 4);
System.out.println(log.average() == 20.5);
System.out.println(log.max() == 23.0);
System.out.println(log.countAbove(20.0) == 2);

De som is 82,0, dus het verwachte gemiddelde is 20,5. Deze specifieke waarden hebben een exacte binaire representatie, waardoor deze directe gelijkheidscontroles geschikt zijn voor het voorbeeld. Controleer ook een leeg logboek volgens het gedocumenteerde gedrag, een grenswaarde die overeenkomt met een meting en de weigering van ongeldige invoer zonder wijziging van het aantal. Geautomatiseerde testhulpmiddelen bouwen voort op hetzelfde idee van een bekende invoer en een verwacht resultaat.

Wijzig de opslag alleen als die de zoekvragen blijft ondersteunen

Een interface die alleen average, count en max aanroept, hoeft niet te weten of het logboek een lijst bevat. Velden voor een lopende som, een aantal en een maximum kunnen die drie vragen beantwoorden zonder elke meting te bewaren.

Voor een vraag met een willekeurige countAbove(limit) is meer informatie nodig. De meetreeksen 18, 22, 23 en 20, 20, 23 hebben dezelfde som 63, hetzelfde aantal 3 en hetzelfde maximum 23, maar hun aantallen boven 20 zijn 2 en 1. Als je alleen die drie samenvattende waarden bewaart, gaat het onderscheid verloren. De publieke methoden beschrijven wat na een wijziging van de opslag moet blijven werken.

Combineer de ontwerpideeën

Een receptenboek kan een private lijst met recepten beheren. Elk recept kan ingrediënten bevatten die in gram worden gemeten en een bereidingstijd in minuten. Gelijkheid kan controles op duplicaten ondersteunen, terwijl een gebruikersinterface via methoden van het boek recepten toevoegt, toont en doorzoekt. Een gekopieerde resultaatlijst kan de lijstinhoud beschermen terwijl receptobjecten gedeeld blijven; bepaal of aanroepers die recepten mogen wijzigen.

Werk in kleine stappen: implementeer één methode, controleer die en voeg dan de bijbehorende opdracht toe. Als een wijziging een bestaand resultaat stukmaakt, keer dan terug naar een werkende toestand en onderzoek die wijziging afzonderlijk voordat je een andere functie toevoegt.