Overerving, interfaces en polymorfisme in Java

Overerving maakt een subklasse op basis van een bestaande superklasse. In class Student extends Person is elke student een persoon. Een studentobject bevat zijn persoonstoestand en zijn extra studenttoestand samen in één object.

Voeg de studentspecifieke onderdelen toe

Hier zie je een kleine superklasse en een subklasse:

class Person {
    private String name;
    public Person(String name) { this.name = name; }
    public String getName() { return name; }
}

class Student extends Person {
    private int credits;
    public Student(String name) { super(name); }
    public void study() { credits += 5; }
    public int getCredits() { return credits; }
}

Student overerft getName(). De klasse voegt een veld voor studiepunten en twee methoden toe. Na Student s = new Student("Ada Lovelace"); begint het veld voor studiepunten op 0. Twee aanroepen van s.study() verhogen het eerst tot 5 en dan tot 10. s.getName() geeft nog steeds “Ada Lovelace” terug: de overgeërfde methode leest het private veld dat in Person is gedeclareerd.

De instructie super(name) geeft de naam door aan de constructor van Person. Constructoren worden niet overgeërfd, dus Student declareert een eigen constructor. Een subklasse mag methoden toevoegen en overgeërfd gedrag overschrijven, maar kan een overgeërfde public methode niet uit haar publieke interface verwijderen.

Bepaal welke leden toegankelijk zijn

Private leden worden niet overgeërfd. Het private veld name bestaat nog steeds in elke student, maar Student kan het niet rechtstreeks lezen. Door het veld private te houden en een getter aan te bieden, kan Person zijn eigen gegevens beheren. Voor protected toegang tot instanties over pakketgrenzen heen geldt een extra beperking: code in een subklasse benadert het lid via zichzelf of een referentie van het eigen subklassetype, niet via een willekeurige superklassereferentie.

Test de relatie voordat je uitbreidt

Java staat één directe superklasse per klasse toe. Een keten zoals GraduateStudent extends Student en Student extends Person is geldig; extends Student, Teacher is dat niet. Een klasse zonder expliciete superklasse breidt Object uit. Object zelf heeft geen superklasse.

Gebruik de is-een-test: kan elk subklasseobject worden gebruikt waar de superklasse wordt verwacht? Een vrachtwagen is een voertuig. Een klant heeft een adres, maar een klant is geen adres. Gebruik voor die tweede relatie compositie:

class Customer {
    private Address address;
}

Hier is Address een andere klasse. Via het veld kan een klant een adres gebruiken zonder te beweren er zelf één te zijn. Als je een klasse alleen uitbreidt om een handige methode te gebruiken, erf je ook het hele publieke contract ervan. Tot slot kan een final-klasse niet worden uitgebreid. Omdat String final is, compileert class ShortString extends String niet.

Een subklasseconstructor moet de constructie van het superklassedeel van hetzelfde object regelen. Hij kan een superklasseconstructor aanroepen met super(...), of de taak doorgeven aan een andere constructor in de eigen klasse met this(...).

Kies de superklasseconstructor

class Person {
    private final String name;
    Person(String name) { this.name = name; }
}
class Student extends Person {
    private final String studentId;
    Student(String name, String studentId) {
        super(name);
        this.studentId = studentId;
    }
    Student(String name) {
        this(name, "no id yet");
    }
}

De constructor met twee argumenten geeft de naam door aan Person en slaat zelf de identificatie op. De constructor met één argument geeft de taak aan die constructor door. Een constructor bevat hoogstens één expliciete constructoraanroep: this(...) of super(...). Als je de this(...)-keten volgt, kom je uiteindelijk bij een constructor die super(...) aanroept.

Als geen van beide is geschreven, voegt Java super() in. Dat mislukt hier omdat Person alleen een constructor heeft die een naam vereist. Zodra je een constructor declareert, levert Java geen standaardconstructor zonder parameters. Een klasse zonder gedeclareerde constructor krijgt een standaardconstructor die super() aanroept.

new Person(name) schrijven binnen Student doet iets anders: het construeert een afzonderlijk object. Het initialiseert niet de persoonstoestand van de huidige student en vervangt ook niet de vereiste aanroep van de superklasseconstructor.

Volg de initialisatie in volgorde

class Base {
    Base() { System.out.println("Base ready"); }
}
class Middle extends Base {
    Middle() { System.out.println("Middle ready"); }
}
class Top extends Middle {
    Top() { super(); System.out.println("Top ready"); }
}

new Top() doorloopt de constructorketen tot aan Object. Als de aanroepen terugkeren, is de uitvoer “Base ready”, “Middle ready” en dan “Top ready”. De veldinitialisatoren van elke klasse worden uitgevoerd nadat de superklasseconstructor is teruggekeerd en vóór de rest van de constructorbody van die klasse.

Een overschrijfbare methode die door een superklasseconstructor wordt aangeroepen, kan al een overschrijving in een subklasse uitvoeren. Als die overschrijvende methode een referentieveld van de subklasse leest waarvan de toewijzing nog niet is uitgevoerd, ziet ze null, zelfs als het veld een initialisator bij de declaratie heeft. Gebruik constructoren om de toestand te initialiseren; vermijd aanroepen van methoden die subklassen kunnen overschrijven.

Herken de wijziging in Java 25

In Java 25 kan een constructor parameters valideren vóór zijn expliciete constructoraanroep:

Student(String name, String studentId, int credits) {
    if (credits < 0) {
        throw new IllegalArgumentException("negative credits");
    }
    super(name);
    this.studentId = studentId;
}

Java 25 staat ook eenvoudige vroege toewijzingen toe aan velden die in de huidige klasse zonder initialisator bij de declaratie zijn gedeclareerd. Het blijft verboden om vóór de aanroep de velden van het huidige object te lezen, de instantiemethoden ervan aan te roepen of this door te geven. Houd bij standaardtaalversies van vóór Java 25 super(...) of this(...) als eerste. Java 22–24 bood eerdere vormen als voorlopige functies.

Een overschrijvende methode geeft een subklasse een eigen implementatie van een overgeërfde instantiemethode. De naam en parametertypen komen overeen met die van de oorspronkelijke methode, zodat aanroepers dezelfde operatie kunnen blijven gebruiken.

Breid een werkende methode uit

Stel dat de jaarbeloning van een werknemer uit twaalf maandbetalingen bestaat. Een manager ontvangt daarnaast een jaarlijkse bonus:

class Employee {
    private final double monthlySalary;
    Employee(double monthlySalary) {
        this.monthlySalary = monthlySalary;
    }
    public double yearlyPay() { return 12 * monthlySalary; }
}
class Manager extends Employee {
    private final double bonus;
    Manager(double monthlySalary, double bonus) {
        super(monthlySalary);
        this.bonus = bonus;
    }
    @Override
    public double yearlyPay() {
        return super.yearlyPay() + bonus;
    }
}

Voor new Manager(3000.0, 5000.0) geeft de aanroep van de superklassemethode 36.000,0 terug. Als je daar 5.000,0 bij optelt, krijg je 41.000,0. super.yearlyPay() kiest bewust de implementatie van de superklasse. De superklassemethode blijft beschikbaar binnen de subklasse, ook al voeren gewone aanroepen op de manager de overschrijvende methode uit.

Als je return yearlyPay() + bonus; schrijft, roep je de eigen methode van de manager opnieuw aan. Geen enkele aanroep wordt voltooid, zodat de uitvoering uiteindelijk mislukt met StackOverflowError. De ontbrekende super. verandert de betekenis van de aanroep.

Laat de compiler de signatuur controleren

Zet @Override boven elke overschrijvende methode. Een spelfout zoals yearlypay() of een extra parameter veroorzaakt dan een compilatiefout. Zonder de annotatie kan Java een nieuwe methode accepteren die aanroepers nooit gebruiken.

Een geldige overschrijving volgt deze regels:

• De parametertypen komen precies overeen.
• Het retourtype is hetzelfde, of een subtype bij een objectretourtype. Die toegestane versmalling heet een covariant retourtype.
• De toegang is minstens even open als die van de overgeërfde methode.
• De methode voegt geen gecontroleerde excepties toe die de overgeërfde declaratie verbiedt.

Zo kan public String toString() niet worden vervangen door String toString() met pakkettoegang. Bestaande aanroepers moeten toegang houden.

Onderscheid overschrijven van overladen en verbergen

role() en role(String language) zijn overladen methodevarianten; de tweede vervangt de eerste niet. De keuze tussen overladen methoden gebruikt tijdens de compilatie de gedeclareerde argumenttypen. Statische methoden worden ook gekozen op basis van het type dat tijdens de compilatie wordt gebruikt, dus worden ze niet dynamisch overschreven.

Een private methode wordt niet overgeërfd; een methode met dezelfde naam in de subklasse staat daar los van. Een final-methode kan niet worden overschreven en constructoren kunnen niet worden overschreven. Naast compileren moet de methode nog steeds haar oorspronkelijke doel vervullen. Een overschrijvende methode van een manager die de maandbeloning teruggeeft, zou code die jaarbeloningen optelt verstoren, ook als de signatuur correct was.

Elke Java-klasse breidt Object direct of indirect uit. Arrays zijn ook objecten. Deze gemeenschappelijke basis biedt methoden zoals toString(), equals(Object), hashCode() en getClass(), ook als een klasse er zelf geen declareert.

Vervang de standaardbeschrijving bij het afdrukken

De overgeërfde Object.toString() levert een klassenaam, @ en de hashcode van het object in hexadecimale notatie. Tekst zoals “school.Person@1b6d3586” geeft de klasse aan, maar zegt niets over de gegevens van de persoon. Het getal kan per uitvoering veranderen en is geen geheugenadres dat door Java wordt gegarandeerd.

Een bruikbare overschrijvende methode toont de velden die lezers nodig hebben. Hier heeft een studentobject getName() overgeërfd en bevat het een veld credits:

@Override
public String toString() {
    return getName() + " (" + credits + " credits)";
}

Voor een student met de naam Ada Lovelace en 10 studiepunten drukt System.out.println(s) “Ada Lovelace (10 credits)” af. De afdrukaanroep haalt automatisch de tekst van het object op. Stringconcatenatie doet dit ook: "Student: " + s bevat dezelfde beschrijving.

Voor een null-referentie leveren afdrukken en concatenatie “null” op. Een expliciete aanroep s.toString() wanneer s null is, werpt NullPointerException op, omdat er geen object is dat die aanroep kan ontvangen.

Als Person.toString() al de naam van de persoon teruggeeft, kan een subklasse daarop voortbouwen:

@Override
public String toString() {
    return super.toString() + ", student id " + studentId;
}

Voor identificatie “S-17” levert dat “Ada Lovelace, student id S-17” op. Hoe bruikbaar super.toString() is, hangt af van wat de superklasse werkelijk teruggeeft. Als die nog de versie van Object gebruikt, draagt die de standaardtekst met klasse en hashcode bij.

Houd identiteit en klasse-informatie gescheiden

Object.equals(Object) vergelijkt identiteit: de methode geeft waar terug als beide referenties naar hetzelfde object verwijzen. Twee afzonderlijke new Person("Ada")-objecten zijn volgens die overgeërfde implementatie niet gelijk, ook al komen hun namen overeen. Klassen zoals String, Integer en ArrayList bieden overschrijvende methoden op basis van waarde.

getClass() geeft de werkelijke klasse tijdens de uitvoering:

Person p = new Student("Ada Lovelace");
System.out.println(p.getClass().getSimpleName());

Dit drukt “Student” af als Student de getoonde constructor heeft. Het gedeclareerde type van de variabele verandert de klasse van het object niet. getClass() is final en kan niet worden overschreven.

hashCode() ondersteunt collecties op basis van hashcodes. Andere methoden van Object zijn de protected methode clone() en de methoden wait(), notify() en notifyAll() voor coördinatie van threads.

Controleer de exacte spelling

Java maakt onderscheid tussen toString() en tostring(). Een methode toString(String prefix) is een overladen methodevariant, dus wordt die bij het afdrukken niet aangeroepen. Beide fouten worden door @Override opgevangen. Een tekstrepresentatie bepaalt ook niet de gelijkheid: twee objecten kunnen dezelfde tekst afdrukken terwijl ze bij vergelijking toch ongelijk zijn.

Twee objecten kunnen dezelfde waarde vertegenwoordigen zonder hetzelfde object te zijn. Een boekencatalogus kan twee boekobjecten als gelijk behandelen als hun cataloguscode en editie overeenkomen. Definieer die regel door equals(Object) te overschrijven en houd de hashcode daarmee consistent.

Vergelijk de velden die de waarde bepalen

import java.util.Objects;

final class Book {
    private final String code;
    private final int edition;
    Book(String code, int edition) {
        this.code = code;
        this.edition = edition;
    }
    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof Book b)) return false;
        return edition == b.edition && Objects.equals(code, b.code);
    }
    @Override
    public int hashCode() {
        return Objects.hash(code, edition);
    }
}

De identiteitscontrole accepteert hetzelfde object snel. De typecontrole wijst een niet-gerelateerd object of null af en introduceert daarna b als een Book. Voor primitieve editiewaarden wordt == gebruikt; Objects.equals vergelijkt codes veilig, zelfs als een code null is. Twee boeken met code “B-1042” en editie 2 zijn bij vergelijking gelijk. Editie 3 levert een andere waarde op.

De parameter moet Object zijn. Als je equals(Book other) schrijft, voeg je een overladen methodevariant toe; de overgeërfde equals(Object) blijft bestaan. Bibliotheekcode die die signatuur aanroept, zou nog steeds identiteit vergelijken. Door @Override mislukt de verkeerde declaratie tijdens de compilatie.

Volg de beloften van gelijkheid

Voor referenties die niet null zijn, moet gelijkheid zijn:

• Reflexief: een object is gelijk aan zichzelf.
• Symmetrisch: als je de twee objecten omwisselt, krijg je hetzelfde antwoord.
• Transitief: als het ene gelijk is aan een tweede en het tweede aan een derde, is het eerste gelijk aan het derde.
• Consistent: herhaalde vergelijkingen geven hetzelfde resultaat zolang de vergeleken gegevens onveranderd blijven.

Een object moet ook ongelijk zijn aan null. Gelijke objecten moeten gelijke hashcodes teruggeven. Ongelijke objecten mogen een hashcode delen: een hashbotsing bewijst geen gelijkheid. Leid de hashcode af uit dezelfde velden als de gelijkheidsbepaling, zoals Objects.hash(code, edition) hier doet.

Een hashcollectie gebruikt de hashcode om kandidaten te vinden voordat ze de gelijkheid controleert. Als je alleen equals overschrijft, kan een verzameling afzonderlijke gelijke boeken behouden of kan een map een gelijke sleutel mogelijk niet vinden. Als je een veld verandert dat voor de hashcode wordt gebruikt terwijl het object als sleutel is opgeslagen, kan dat object onder zijn oude hashcode opgeborgen blijven.

Bescherm symmetrie tussen subklassen

Stel dat een uitbreidbare Book elke instanceof Book accepteert, terwijl Ebook bestandsgrootte toevoegt aan de gelijkheidsbepaling en alleen e-books accepteert. Een boek kan een e-book met dezelfde code en editie accepteren, maar het e-book wijst het boek af. De vergelijking heeft haar symmetrie verloren.

Eén aanpak vereist overeenkomende werkelijke klassen, waarbij je vóór getClass() op null controleert. Een andere maakt de gelijkheidsbepaling van de superklasse final, zodat subklassen de gelijkheidsregel niet kunnen uitbreiden. Een final-waardeklasse, zoals hierboven, vermijdt gelijkheidsbepaling tussen subklassen volledig. Records genereren gelijkheidsbepaling en hashcodes uit hun componenten; enumconstanten hebben al een gelijkheidsbepaling op basis van identiteit die bij hun vaste waarden past.

Een abstracte klasse is een basisklasse waarvan je niet rechtstreeks een instantie kunt maken. Ze kan gemeenschappelijke velden en werkende methoden bevatten en tegelijk geselecteerde operaties overlaten aan subklassen om aan te vullen.

Laat een vereiste operatie abstract

abstract class Shape {
    private final String name;
    Shape(String name) { this.name = name; }
    public abstract double area();
    public String describe() {
        return name + " with area " + area();
    }
}
class Rectangle extends Shape {
    private final double width;
    private final double height;
    Rectangle(double width, double height) {
        super("rectangle");
        this.width = width;
        this.height = height;
    }
    @Override
    public double area() { return width * height; }
}

area() heeft een signatuur en een puntkomma, zonder body. De methode legt vast wat elke concrete vorm moet aanbieden. Omdat Shape een abstracte methode bevat, moet de klasse ook abstract zijn. Rectangle levert de ontbrekende implementatie en je kunt er een instantie van maken.

Voor new Rectangle(3.0, 4.0) slaat de superklasseconstructor “rectangle” op. De subklasseconstructor slaat de afmetingen op. De oppervlakte is 12,0 vierkante meter als de afmetingen in meters zijn. Een aanroep van describe() geeft “rectangle with area 12.0” terug. De aanroep van area() in de overgeërfde methode voert de implementatie van de rechthoek uit.

Gebruik constructoren en concrete methoden op de gewone manier

Een abstracte klasse kan velden, constructoren en methoden met een body hebben, met de gebruikelijke toegangsniveaus. Haar constructor wordt uitgevoerd als onderdeel van het maken van een subklasseobject. new Shape() is verboden, ook als er een passende constructor bestaat; new Rectangle(3.0, 4.0) is geldig.

Een tweede subklasse kan dezelfde overgeërfde beschrijving gebruiken terwijl ze de oppervlakte anders berekent. Een cirkelimplementatie geeft Math.PI * radius * radius terug. Voor straal 1,5 m is de berekening π maal 2,25, ongeveer 7,07 vierkante meter. De gedeelde methode describe() heeft geen cirkelspecifieke tak nodig.

Een variabele kan nog steeds het abstracte type hebben: Shape s = new Rectangle(3.0, 4.0);. Java verbiedt het construeren van de abstracte klasse, niet het verwijzen naar een concreet object via dat type.

Maak ontbrekend werk zichtbaar als compilatiefout

Elke concrete subklasse moet implementaties van alle abstracte methoden aanbieden of overerven. Een subklasse die sommige methoden onvoltooid laat, moet ook als abstract worden gedeclareerd. Als een tijdelijke invulling van area() 0 zou teruggeven, zou een onvolledige concrete subklasse kunnen compileren en ongemerkt verkeerde resultaten geven. Door area() abstract te declareren, maak je dat ontbrekende werk zichtbaar voor de compiler.

Abstracte methoden kunnen niet private, static of final zijn: elk van die modifiers zou de overschrijving in de subklasse verhinderen die de operatie levert. Een abstracte klasse mag geen abstracte methoden bevatten; de modifier verhindert dan alleen rechtstreekse constructie. Gebruik dit soort basisklasse als haar subklassen slagen voor de is-een-test en baat hebben bij gedeelde toestand of code.

Een interface benoemt een functionaliteit die verschillende klassen kunnen bieden. Ze legt vast welke methoden via die functionaliteit beschikbaar zijn, zonder dat de klassen dezelfde instantievelden of superklasse hoeven te delen.

Declareer en implementeer de methoden

interface Chargeable {
    int batteryPercent();
    void charge(int minutes);
}
class Phone implements Chargeable {
    private int battery;
    Phone(int battery) { this.battery = battery; }
    @Override
    public int batteryPercent() { return battery; }
    @Override
    public void charge(int minutes) {
        battery = Math.min(100, battery + 2 * minutes);
    }
}

De abstracte methoden van de interface zijn impliciet public. De implementerende methoden moeten expliciet public zijn; als je die modifier weglaat, wordt de toegang beperkt en mislukt de compilatie. Een concrete klasse moet geschikte public implementaties van elke abstracte methode aanbieden of overerven. Een abstracte implementerende klasse mag sommige methoden overlaten aan haar subklassen.

Voor een telefoon op 35 procent voegt charge(20) 40 procentpunten toe en komt de lading uit op 75 procent. Nog eens 20 minuten zou vóór de begrenzing 115 opleveren, dus slaat Math.min 100 op. Een ElectricScooter kan dezelfde interface implementeren en daarbij slechts één punt per minuut toevoegen: vanaf 50 procent bereikt de scooter na 20 minuten 70. De interface legt de beschikbare operatie vast, terwijl de klasse het gedrag ervan levert.

Gebruik de interface als type

Chargeable device = new Phone(35);
device.charge(20);
System.out.println(device.batteryPercent());

Dit drukt 75 af. Een aanroeper kan de methoden van de interface en de public methoden gebruiken die op elk object beschikbaar zijn. Operaties die alleen bij de telefoon horen, zijn niet beschikbaar via device, tenzij de gedeclareerde interface die aanbiedt.

Interfaces kunnen ook het type zijn van parameters, retourwaarden en lijstelementen. Een methode die Chargeable accepteert, kan met een telefoon of een scooter werken zonder de indeling van hun velden te kennen. De Java-bibliotheek gebruikt dezelfde aanpak: List heeft implementaties zoals ArrayList en LinkedList; Runnable declareert run(); Comparable declareert een natuurlijke vergelijking.

Combineer meer dan één functionaliteit

Een klasse breidt één klasse uit en mag meerdere interfaces implementeren. De volgorde is class Phone extends Device implements Chargeable, Connectable. Een interface kan meerdere interfaces uitbreiden: interface SmartDevice extends Chargeable, Connectable. Implementerende klassen moeten dan alle overgeërfde abstracte operaties aanbieden.

Een interface heeft geen constructoren en geen instantievelden. new Chargeable() compileert niet. Een gedeclareerd veld zoals int FULL = 100; is impliciet een public static final constante, te lezen als Chargeable.FULL.

Een abstracte interfacemethode levert geen werkende code. De implementatie kan uit de klasse zelf komen of uit een overgeërfde public superklassemethode. Default-methoden zijn de interfacemethoden die overgeërfd instantiegedrag kunnen leveren.

Interfaces kunnen zowel werkende code als abstracte methodedeclaraties aanbieden. De modifier van de methode bepaalt of implementerende objecten de methode overerven, aanroepers de interfacenaam gebruiken of alleen code binnen de interface de methode kan gebruiken.

Bouw standaardgedrag op uit het contract

interface Chargeable {
    int batteryPercent();
    void charge(int minutes);
    default boolean needsCharge() {
        return batteryPercent() < 20;
    }
    static int clamp(int percent) {
        return Math.max(0, Math.min(100, percent));
    }
}

Een default-methode is een public instantiemethode met een body. Een telefoon die 15 procent meldt, overerft needsCharge() en geeft waar terug. Bij 20 procent geeft de methode onwaar terug. De default-methode roept de abstracte operatie batteryPercent() aan; die leest geen privaat veld van een telefoon. Een klasse mag de methode overschrijven met een eigen public implementatie.

Een statische interfacemethode hoort bij de interface: Chargeable.clamp(130) geeft 100 terug en Chargeable.clamp(-5) geeft 0 terug. Implementerende klassen overerven de methode niet, dus Phone.clamp(130) is geen geldige aanroep van deze methode. Default-methoden en statische interfacemethoden zijn ingevoerd in Java 8.

Sinds Java 9 mag een interface ook privémethoden declareren om hulpcode tussen haar eigen methoden te delen. Een private instantiehulpmethode ondersteunt default-methoden; een private statische hulpmethode kan ook statische methoden ondersteunen. Implementerende klassen kunnen deze hulpmethoden niet rechtstreeks aanroepen.

Los conflicten tussen default-methoden op

Twee niet-verwante interfaces kunnen dezelfde signatuur aanbieden:

interface Lamp {
    default String describe() { return "lamp"; }
}
interface Speaker {
    default String describe() { return "speaker"; }
}
class SmartLamp implements Lamp, Speaker {
    @Override
    public String describe() {
        return Lamp.super.describe() + " and "
             + Speaker.super.describe();
    }
}

Zonder de overschrijvende methode heeft SmartLamp een conflict en compileert de klasse niet. De gekwalificeerde aanroepen InterfaceName.super.method() selecteren de afzonderlijke default-methoden van de directe superinterfaces. Deze implementatie geeft “lamp and speaker” terug.

Ook een abstracte declaratie in een superklasse kan vereisen dat een concrete subklasse de methode implementeert; een default-methode van een interface neemt die verplichting niet weg.

Houd rekening met bestaande implementerende klassen

Als je een abstracte methode toevoegt, moet elke concrete implementerende klasse een passende implementatie aanbieden of overerven. Een default-methode voorkomt die wijziging vaak door werkend gedrag te bieden, maar kan een conflict met een andere overgeërfde methode veroorzaken. Default-methoden helpen een interface zich te ontwikkelen; de overervingsregels bepalen nog steeds of de resulterende klassen compileren.

Een abstracte klasse en een interface kunnen allebei vereiste methoden definiëren. De keuze hangt af van de relatie tussen objecten en van de vraag of hun implementatie een gedeelde instantietoestand nodig heeft.

Vergelijk wat beide bieden

Interfacevelden zijn public static final constanten, geen gegevens per object. Private interfacehulpmethoden ondersteunen de eigen werkende methoden van de interface; ze maken geen private toestand voor elk implementerend object.

Zet nauw verwante toestand in een abstracte klasse

Een tekenprogramma heeft cirkels, rechthoeken en driehoeken. Elke vorm slaat een naam en een positie op en berekent de oppervlakte op een andere manier. Een abstracte Shape kan de gemeenschappelijke velden en constructor bewaren, werkende methoden voor beweging of beschrijving aanbieden en area() abstract declareren.

Alle concrete vormen zijn soorten Shape, dus andere code kan om een vorm vragen en elk van deze vormen ontvangen. Zo kan ook een abstracte Enemy gezondheidspunten en een gemeenschappelijke methode takeDamage(int points) bevatten en de beweging overlaten aan specifieke vijandklassen. De gemeenschappelijke toestand geeft deze basisklassen nuttig werk.

Zet een breed bruikbare functionaliteit in een interface

Hetzelfde tekenprogramma kan vormen, tekstlabels en afbeeldingen exporteren. Exporteren maakt van een tekstlabel geen vorm en deze objecten kunnen al verschillende superklassen nodig hebben. Een interface Exportable kan String exportText() declareren. Elke klasse implementeert de operatie met haar eigen gegevens.

Een klasse mag de twee rollen combineren: class Circle extends Shape implements Exportable. De superklasse biedt de toestand van de vorm en gemeenschappelijke code; de interface maakt de cirkel bruikbaar voor exportcode. Een klasse die meerdere interfaces implementeert, belooft meerdere functionaliteiten zonder instantievelden van die interfaces over te erven.

Combineer een contract met een gedeeltelijke implementatie

Een abstracte klasse kan een interface implementeren en slechts enkele methoden voltooien. Concrete subklassen vullen de resterende operaties aan. List en AbstractList van Java gebruiken deze opzet; ArrayList breidt AbstractList uit. Aanroepers kunnen op de interface vertrouwen terwijl implementerende klassen waar passend een basisklasse hergebruiken.

Met List<String> names = new ArrayList<>(); kunnen aanroepers bijvoorbeeld namen toevoegen, lezen en verwijderen via List. Als je de initialisator vervangt door new LinkedList<>(), blijven die aanroepen werken. Een parameter die als ArrayList<String> is gedeclareerd, zou een LinkedList<String> afwijzen, ook als die alleen lijstoperaties nodig heeft.

Een abstracte klasse met alleen abstracte methoden neemt nog steeds de enige superklasseplaats van de subklasse in. Ze is niet uitwisselbaar met een interface. Kies de interface als alleen het gemeenschappelijke contract nodig is en voeg een basisklasse toe als verwante implementaties baat hebben bij gedeelde toestand of code.

Polymorfisme laat een algemene referentie naar objecten van verschillende subtypen verwijzen. Het object behoudt zijn volledige toestand en gedrag; de referentie geeft aanroepers een bepaalde kijk op de beschikbare operaties.

Benoem de twee typen

Person p = new Student("Ada Lovelace", "S-17");

Het gedeclareerde type, ook statisch type genoemd, is Person: het staat in de variabeledeclaratie. Het werkelijke type, of uitvoeringstype, is Student: dat is de klasse waarvan new een instantie maakt. De werkelijke klasse van het object verandert niet na de constructie.

Een studentreferentie toewijzen aan een persoonsreferentie is een upcast. Die gaat automatisch en is veilig omdat elke student een persoon is. Naar dezelfde student kan ook worden verwezen met een Object-variabele. Een implementerend object kan via upcasting worden toegewezen aan een interface die het implementeert, zoals in Chargeable c = new Phone(35);.

Door de toewijzing worden geen studentgegevens verwijderd. Er is nog steeds één studentobject met zijn studentidentificatie, overgeërfde persoonsgegevens en overschreven methoden. Als je het een algemenere referentie geeft, verandert wat de compiler via die referentie toegankelijk maakt.

Controleer aanroepen aan de hand van het gedeclareerde type

Als Person getName() declareert, compileert p.getName(). Als alleen Student getStudentId() declareert, compileert p.getStudentId() niet. De compiler controleert de publieke interface van Person, ook als de initialisator duidelijk een student maakt.

De omgekeerde toewijzing Student s = p; wordt niet geaccepteerd zonder expliciete typeconversie. Een persoonsreferentie kan verwijzen naar een persoon die geen student is. Die beperking beschermt code tegen het behandelen van een object als een subtype dat het niet heeft.

Laat parameters en lijsten meerdere subtypen accepteren

Een methode static void printCard(Person person) kan een Person-, Student- of Teacher-object ontvangen, aangenomen dat de laatste twee Person uitbreiden. De code kan vertrouwen op het contract van de persoon. Ook een retourtype kan algemeen zijn, bijvoorbeeld bij een methode die een Shape teruggeeft.

Een lijst met een algemeen elementtype kan verschillende vormklassen opslaan:

List<Shape> shapes = new ArrayList<>();
shapes.add(new Circle(1.5));
shapes.add(new Rectangle(3.0, 4.0));
for (Shape shape : shapes) {
    System.out.println(shape.area());
}

Hier komen List en ArrayList uit java.util en biedt elke concrete vorm area() aan. De lus gebruikt alleen die gemeenschappelijke operatie.

Een List<Circle> is geen List<Shape>. Als dat wel zo was, zou code die de lijst als vormenlijst ontvangt, een rechthoek kunnen toevoegen aan een lijst die beloofd is alleen cirkels te bevatten. Als een methode List<Shape> vereist, maak de lijst dan vanaf het begin met dat elementtype.

Een methodeaanroep wordt in twee fasen afgehandeld. Tijdens de compilatie controleert Java de gedeclareerde typen en kiest het een methodesignatuur. Tijdens de uitvoering kiest dynamische binding de overschrijvende instantiemethode voor de werkelijke klasse van het object.

Volg een aanroep binnen een overgeërfde methode

class A {
    String who() { return "A"; }
    String hello() { return "Hello from " + who(); }
}
class B extends A {
    @Override String who() { return "B"; }
}
class C extends B { }

Voor A x = new C(); is x.hello() toegestaan omdat A hello() declareert. Klasse C overschrijft hello() niet en B doet dat evenmin, dus voert Java de implementatie in A uit.

Binnen die methode betekent who() hetzelfde als this.who(). De ontvanger is nog steeds het C-object. Java zoekt vanaf C en vindt vervolgens de dichtstbijzijnde implementatie van who() in B. Het resultaat is “Hello from B”. Als een overgeërfde methode wordt uitgevoerd, verandert de ontvanger niet in een object van de superklasse.

Kies een overladen methode vóór een overschrijvende methode

static String kind(Object value) { return "object"; }
static String kind(String value) { return "string"; }

Binnen een klasse die deze methoden bevat, kiest Object value = "hi"; kind(value) voor kind(Object) en geeft “object” terug. Het gedeclareerde type van de variabele is Object; Java bekijkt tijdens de uitvoering de overladen methoden niet opnieuw op basis van de werkelijke string.

Bij een instantieaanroep kan dynamische binding nog steeds een overschrijving van de al gekozen signatuur selecteren. Ze kan niet overschakelen naar een andere overladen methodevariant die alleen specifieker lijkt voor het werkelijke argument. Bepaal eerst de signatuur en zoek daarna de overschrijvende methode.

Herken aanroepen en leden die anders worden geselecteerd

Als P String label = "P"; declareert en Q extends P zijn eigen String label = "Q"; declareert, leest P p = new Q(); p.label “P”. Velden worden verborgen, niet overschreven. Beide velden bestaan in het object. Gebruik overgeërfde veldnamen liever niet opnieuw, omdat het referentietype ervoor kan zorgen dat toegangen die er hetzelfde uitzien verschillende toestand lezen.

super.method() kiest de implementatie van de superklasse, inclusief een implementatie die de superklasse overerft. Als de gekozen methode zelf een gewone aanroep op this doet, kan die interne aanroep nog steeds worden gebonden aan een overschrijvende methode van een subklasse.

Een algemene referentie heeft soms toegang nodig tot een operatie die maar bij één subtype hoort. Een downcast vertelt de compiler dat de referentie als dat subtype moet worden behandeld. Tijdens de uitvoering controleert Java of het object al dat type heeft.

Begrijp wat een expliciete typeconversie verandert

Stel dat Person p naar een student verwijst. Student s = (Student) p; maakt s.getStudentId() mogelijk. Beide variabelen verwijzen nog steeds naar hetzelfde object. De conversie kopieert het object niet, verandert de werkelijke klasse niet en voegt geen studentvelden toe aan een gewone persoon.

Als p werkelijk naar new Person("Grace Hopper") verwijst, werpt die conversie ClassCastException op. Een compiler accepteert de mogelijke relatie van persoon naar student, maar het object moet daar tijdens de uitvoering nog steeds aan voldoen. Een expliciete typeconversie tussen klassen die niet verwant kunnen zijn, zoals een conversie van een Person-referentie naar de final-klasse Integer, mislukt tijdens de compilatie.

Dit verschilt van een primitieve conversie: (int) 3.9 maakt de gehele waarde 3. Een expliciete conversie van een referentie controleert en verandert alleen het type waarmee een bestaande referentie wordt gebruikt.

Combineer de test en de nieuwe variabele

Sinds Java 16 maakt patroonherkenning het veilige geval compact:

static void showStudentId(Person person) {
    if (person instanceof Student student) {
        System.out.println(student.getStudentId());
    }
}

De test is waar voor een student of een subklasse van student. De variabele student is beschikbaar binnen het blok, waar bekend is dat de test is geslaagd. Een gewone persoon slaat het blok over. Een null-referentie maakt de test ook onwaar, zodat het blok nooit probeert een methode op null aan te roepen.

De oudere vorm test person instanceof Student en declareert daarna Student student = (Student) person; binnen de tak voor een geslaagde test. Beide vormen beschermen de expliciete typeconversie. Een test van een niet-gerelateerd object elders beschermt een conversie van person niet; de test en de conversie moeten over dezelfde referentie gaan.

Een upcast heeft geen expliciete typeconversie nodig. Person person = student; compileert al en kan niet mislukken door een typeverschil. Een expliciete conversie van null naar een compatibel referentietype levert null op; als je dat resultaat gebruikt voor een aanroep van een instantiemethode, mislukt die nog steeds met NullPointerException.

Bepaal of een typetest nodig is

Typetests passen bij code die een Object ontvangt, zoals equals(Object other), of een operatie nodig heeft die alleen bij een subtype hoort, zoals een studentidentificatie. Ze kunnen ook helpen bij het werken met klassen die niet kunnen worden gewijzigd.

Een herhaalde keten van typetests voor een gemeenschappelijke operatie is een ander probleem. Als code elke vormklasse controleert om haar oppervlakte te berekenen, vereist elke toegevoegde vorm een extra tak. Door area() in Shape te declareren en subklassen die te laten implementeren, kan de aanroeper in plaats daarvan shape.area() gebruiken.

Een expliciete typeconversie kan een ontbrekende gemeenschappelijke operatie niet voor elk subtype beschikbaar maken. Zet gemeenschappelijk gedrag in het gemeenschappelijke contract en bewaar een subtypetest voor werk dat werkelijk dat specifieke subtype vereist.

Een methode blijft bruikbaar voor nieuwe klassen als haar parameter precies de operaties beschikbaar maakt die de methode nodig heeft. De aanroeper levert objecten; dynamische binding levert hun afzonderlijke gedrag.

Tel oppervlakten op zonder klassespecifieke takken

static double totalArea(List<Shape> shapes) {
    double total = 0;
    for (Shape shape : shapes) {
        total += shape.area();
    }
    return total;
}

Bij een cirkel met straal 1,5 m, een rechthoek met afmetingen 3,0 m en 4,0 m en een driehoek met basis 4,0 m en hoogte 2,5 m zijn de oppervlakten ongeveer 7,06858, 12,0 en 5,0 vierkante meter. Als je de niet-afgeronde oppervlakte van de cirkel meetelt, krijg je ongeveer 24,07 vierkante meter. Elk object levert zijn eigen area().

Het toevoegen van een klasse Triangle vereist geen wijziging in de lus. De nieuwe klasse implementeert de bestaande vormoperatie. Een negatief resultaat zou het oppervlaktecontract schenden, ook als de overschrijvende methode compileerde; algemene code vertrouwt zowel op de betekenis van de operatie als op haar signatuur.

Dezelfde aanpak werkt met een interface. Een methode chargeAll(List<Chargeable> devices, int minutes) doorloopt apparaten en roept device.charge(minutes) aan. Na 20 minuten bereikt de telefoon die op 35 procent begint 75 procent en de scooter die op 50 procent begint 70 procent. De lus kiest nooit zelf een laadregel.

Laat aanroepers een lijstimplementatie kiezen

Een parameter List<Shape> accepteert zowel een ArrayList<Shape> als een LinkedList<Shape>. Een parameter ArrayList<Shape> wijst de gekoppelde lijst af, hoewel alleen lijstoperaties nodig zijn. Gebruik het meest algemene type dat de vereiste methoden biedt; alles als Object declareren zou te algemeen zijn omdat dat type area() en lijstoperaties mist.

Maak objecten sorteerbaar met Comparable

Comparable<T> definieert de natuurlijke volgorde van een object. Het resultaat van compareTo is negatief als dit object vóór het andere komt, nul als ze dezelfde sorteerrang hebben en positief als het erna komt. Het teken van het resultaat is van belang; het hoeft niet precies −1 of 1 te zijn.

record Runner(String name, int seconds)
        implements Comparable<Runner> {
    @Override
    public int compareTo(Runner other) {
        return Integer.compare(seconds, other.seconds);
    }
}

Een wijzigbare lijst met Mia op 3.605 s, Ken op 3.490 s en Ana op 3.720 s wordt na Collections.sort(runners) Ken, Mia, Ana. list.sort(null) gebruikt ook de natuurlijke volgorde. Bouw een wijzigbare lijst met new ArrayList<>(List.of(...)); een poging om het niet-wijzigbare resultaat van List.of(...) te sorteren werpt UnsupportedOperationException op.

Gebruik Integer.compare in plaats van de waarden af te trekken. Aftrekken kan bij grote waarden met tegengestelde tekens overlopen en het verkeerde teken teruggeven. Hetzelfde idee geldt voor Double.compare bij kommavelden. In dit voorbeeld met hardlopers hebben gelijke tijden dezelfde sorteerrang, ook als de namen verschillen. Dezelfde sorteerrang en objectgelijkheid hoeven dus niet hetzelfde te betekenen. Geef de voorkeur aan een natuurlijke volgorde waarvan het nulresultaat overeenkomt met gelijkheid; documenteer een bewust verschil.

Een enum geeft een vaste verzameling benoemde keuzemogelijkheden een eigen type. enum Size { SMALL, MEDIUM, LARGE } maakt Size size = Size.MEDIUM; mogelijk. Het voorkomt dat een aanroeper de verkeerd gespelde string “MEDUIM” of het gehele getal 7 doorgeeft aan een methode die Size vereist.

Gebruik namen, constanten en switch

Elke enumconstante is één object, dus size == Size.LARGE is een geschikte vergelijking. Een enumvariabele kan ook null zijn. Size.values() geeft alle constanten in declaratievolgorde terug; Size.valueOf("LARGE") vindt de exacte naam. Het opzoeken is hoofdlettergevoelig: “large” veroorzaakt IllegalArgumentException.

name() geeft de gedeclareerde naam terug. ordinal() geeft de positie terug, geteld vanaf nul, dus Size.MEDIUM.ordinal() is 1. Als je een constante invoegt, veranderen latere posities. Daarom is een volgnummer ongeschikt als opgeslagen code of bedrijfswaarde. Standaard geeft toString() ook de naam terug.

Een switch-expressie, standaard sinds Java 14, kan een waarde teruggeven:

String label = switch (size) {
    case SMALL -> "S";
    case MEDIUM -> "M";
    case LARGE -> "L";
};

Door elke constante te noemen, is de expressie volledig zonder default-tak. Deze gevallen gaan ervan uit dat size niet null is; het opsommen van de constanten handelt null niet af.

Geef elke constante betekenisvolle gegevens

enum CupSize {
    SMALL(250), MEDIUM(350), LARGE(500);
    private final int milliliters;
    CupSize(int milliliters) { this.milliliters = milliliters; }
    public int milliliters() { return milliliters; }
}

De puntkomma scheidt de lijst met constanten van de leden. De constructor wordt één keer voor elke constante uitgevoerd wanneer de enum wordt geïnitialiseerd. Hij is impliciet private en aanroepers kunnen geen nieuwe constanten maken met new CupSize(400).

Twee grote bekers en één kleine beker bevatten 1.250 mL, oftewel 1,25 L. Die berekening gebruikt het veld milliliters, niet de posities van de constanten. Als je CupSize.values() doorloopt en elke constante en inhoud afdrukt, krijg je “SMALL: 250 mL”, “MEDIUM: 350 mL” en “LARGE: 500 mL”.

Geef constanten eigen gedrag

Een enum kan een interface implementeren en mag afzonderlijke constanten verschillende methodebody’s geven:

enum Operation {
    ADD { int apply(int a, int b) { return a + b; } },
    MULTIPLY { int apply(int a, int b) { return a * b; } };
    abstract int apply(int a, int b);
}

Operation.MULTIPLY.apply(6, 7) geeft 42 terug. Elke constante vult de abstracte operatie aan. Enums breiden impliciet java.lang.Enum uit; ze kunnen geen andere klasse uitbreiden en gewone klassen kunnen enums niet uitbreiden.

Gebruik een enum voor keuzemogelijkheden die vaststaan wanneer het programma wordt geschreven, zoals richtingen of bestelstatussen. De veranderende productlijst van een winkel hoort bij de gegevens: producten toevoegen zou niet moeten vereisen dat je een enumdeclaratie herschrijft en opnieuw compileert.

Een record is een beknopte gegevensklasse, standaard sinds Java 16. De kop bevat de waarden, componenten genoemd, die elke instantie bepalen: record Point(int x, int y) { }.

Gebruik de gegenereerde leden

De compiler levert voor elke component een private final-veld, een canonieke constructor met die componenten in volgorde en public accessors die ernaar zijn genoemd. Ook levert de compiler equals, hashCode en toString op basis van de componenten.

Point a = new Point(3, 4);
Point b = new Point(3, 4);
System.out.println(a.x());
System.out.println(a.equals(b));
System.out.println(a == b);

Dit drukt 3, true en false af op afzonderlijke regels. Overeenkomende componentwaarden maken de records gelijk, maar de twee new-expressies maken afzonderlijke objecten. Gelijke records hebben gelijke hashcodes. Hun bruikbare gegenereerde tekst bevat de namen van het record en de componenten; huidige JDK’s tonen “Point[x=3, y=4]”. Dat exacte tekstformaat is niet gegarandeerd, dus parse het niet als gegevensformaat.

Accessors zijn x() en y(), niet getX() en getY(). Een setter die this.x = x toewijst, compileert niet omdat het componentveld final is. Een methode kan in plaats daarvan een nieuwe waarde teruggeven: Point moveRight(int dx) { return new Point(x + dx, y); }.

Valideer in een compacte constructor

record Temperature(double celsius) {
    Temperature {
        if (celsius < -273.15) {
            throw new IllegalArgumentException("below absolute zero");
        }
    }
}

Een compacte constructor herhaalt de naam van het record zonder parameterlijst. Hij controleert of normaliseert de binnenkomende parameters; Java wijst de componentvelden na de body toe. Deze controle wijst −300 °C af en accepteert 21,5 °C. Een tekstcomponent kan vóór de automatische toewijzing worden genormaliseerd met name = name.trim();.

Een public record heeft een public compacte constructor nodig. Records mogen ook statische velden, statische methoden en instantiemethoden declareren. Een extra constructor geeft de taak met this(...) door aan de canonieke constructor. Extra instantievelden buiten de componenten zijn verboden.

Bescherm veranderlijke componentobjecten

Final componentvelden maken de onveranderlijkheid ondiep. Een record dat een veranderlijke lijst bevat, verwijst nog steeds naar die lijst:

record Team(String name, List<String> members) {
    Team {
        members = List.copyOf(members);
    }
}

Als java.util.List is geïmporteerd, slaat dit een niet-wijzigbare kopie op. Latere toevoegingen aan de oorspronkelijke lijst beïnvloeden het lidmaatschap van het team niet en team.members().add("Lee") werpt UnsupportedOperationException op. De kopie beschermt de lijststructuur; ze maakt veranderlijke elementobjecten niet diep onveranderlijk.

Records breiden impliciet java.lang.Record uit en zijn final. Ze kunnen geen andere klasse uitbreiden en niet worden uitgebreid, maar kunnen interfaces zoals Comparable implementeren. Gebruik ze voor gegevens die door hun waarden worden bepaald; gebruik een gewone klasse voor veranderende toestand, extra verborgen instantievelden of een uitbreidbare klassenhiërarchie.