Java interfaces uitgelegd

Java interfaces definiëren een contract dat implementerende klassen moeten nakomen. Ze maken abstractie, multiple inheritance mogelijk en bevorderen een schone, modulair architectuur.

Een interface definiëren

Een interface is een volledig abstract type. Al zijn methoden zijn impliciet public abstract, en alle velden zijn public static final. Het wordt gedeclareerd met het interface sleutelwoord:

interface Taal { void getType(); void getVersie(); }

Hier is Taal een interface met twee abstracte methoden.

Een interface implementeren

Interfaces kunnen niet geïnstantieerd worden. Klassen implementeren ze met het implements sleutelwoord en leveren concrete bodies voor alle abstracte methoden.

Voorbeeld 1: Polygon interface

interface Polygon { void getOppervlakte(int lengte, int breedte); } class Rechthoek implements Polygon { @Override public void getOppervlakte(int lengte, int breedte) { System.out.println("De oppervlakte van de rechthoek is " + (lengte * breedte)); } } class Main { public static void main(String[] args) { Rechthoek r = new Rechthoek(); r.getOppervlakte(5, 6); } }

Uitvoer:

De oppervlakte van de rechthoek is 30

Voorbeeld 2: Taal interface

interface Taal { void getNaam(String naam); } class ProgrammeerTaal implements Taal { @Override public void getNaam(String naam) { System.out.println("Programmeertaal: " + naam); } } class Main { public static void main(String[] args) { ProgrammeerTaal taal = new ProgrammeerTaal(); taal.getNaam("Java"); } }

Uitvoer:

Programmeertaal: Java

Meerdere interfaces implementeren

Een klasse mag meerdere interfaces implementeren:

interface A { /* leden */ } interface B { /* leden */ } class C implements A, B { /* implementaties */ }

Een interface uitbreiden

Interfaces kunnen andere interfaces uitbreiden met extends:

interface Lijn { /* leden */ } interface Polygon extends Lijn { /* leden */ }

Een klasse die Polygon implementeert, moet methoden leveren voor zowel Lijn als Polygon leden.

Meerdere interfaces uitbreiden

interface A { /* ... */ } interface B { /* ... */ } interface C extends A, B { /* ... */ }

Waarom interfaces gebruiken?

• Abstractie: Definieert operaties zonder implementatie te dicteren, wat gevarieerd gedrag over klassen toestaat.
• Specificatie: Stelt een helder contract in dat implementerende klassen moeten voldoen.
• Multiple inheritance: Maakt het mogelijk dat een klasse gedrag van meerdere bronnen adopteert.
• Standaard zichtbaarheid: Alle methoden zijn impliciet public; velden zijn public static final.

Voorbeeld van impliciete constanten:

interface Taal { String TYPE = "programmeertaal"; // impliciet public static final void getNaam(); // impliciet public }

Default methoden (Java 8+)

Java 8 introduceerde default methoden, waardoor interfaces concrete methode-bodies kunnen bevatten:

default void getZijden() { System.out.println("Ik kan zijden van een polygon krijgen."); }

Default methoden maken backward compatibility mogelijk bij het toevoegen van nieuwe methoden aan interfaces zonder bestaande implementaties te breken.

Voorbeeld: Default methode gebruik

interface Polygon { void getOppervlakte(); default void getZijden() { System.out.println("Ik kan zijden van een polygon krijgen."); } } class Rechthoek implements Polygon { @Override public void getOppervlakte() { int lengte = 6; int breedte = 5; int oppervlakte = lengte * breedte; System.out.println("De oppervlakte van de rechthoek is " + oppervlakte); } @Override public void getZijden() { System.out.println("Ik heb 4 zijden."); } } class Vierkant implements Polygon { @Override public void getOppervlakte() { int lengte = 5; int oppervlakte = lengte * lengte; System.out.println("De oppervlakte van het vierkant is " + oppervlakte); } } class Main { public static void main(String[] args) { Rechthoek r = new Rechthoek(); r.getOppervlakte(); r.getZijden(); Vierkant v = new Vierkant(); v.getOppervlakte(); v.getZijden(); } }

Uitvoer:

De oppervlakte van de rechthoek is 30 Ik heb 4 zijden. De oppervlakte van het vierkant is 25 Ik kan zijden van een polygon krijgen.

Statische en private methoden (Java 9+)

Interfaces kunnen nu static methoden bevatten, aanroepbaar via de interfacenaam:

interface Polygon { static void helper() { /* ... */ } } Polygon.helper();

Private methoden bieden interne utilitaires voor andere interface-methoden, wat encapsulatie waarborgt.

Praktisch voorbeeld: Polygon berekeningen

import java.lang.Math; interface Polygon { void getOppervlakte(); default void getOmtrek(int... zijden) { int omtrek = 0; for (int zijde : zijden) omtrek += zijde; System.out.println("Omtrek: " + omtrek); } } class Driehoek implements Polygon { private final int a, b, c; private double oppervlakte; Driehoek(int a, int b, int c) { this.a = a; this.b = b; this.c = c; } @Override public void getOppervlakte() { double s = (a + b + c) / 2.0; oppervlakte = Math.sqrt(s * (s - a) * (s - b) * (s - c)); System.out.println("Oppervlakte: " + oppervlakte); } } class Main { public static void main(String[] args) { Driehoek d = new Driehoek(2, 3, 4); d.getOppervlakte(); d.getOmtrek(2, 3, 4); } }

Uitvoer:

Oppervlakte: 2.9047375096555625 Omtrek: 9

In dit voorbeeld levert de Polygon interface een herbruikbare getOmtrek methode, terwijl elke vorm zijn eigen oppervlakteberekening implementeert.