Java Interfaces begrijpen: Definities, Gebruik en Best Practices

Wat is een Interface?

Een interface is een referentietype in Java. Het is vergelijkbaar met een klasse. Het is een verzameling van abstracte methodes. Een klasse implementeert een interface, waardoor de abstracte methodes van de interface worden overgeërfd.

Naast abstracte methodes kan een interface ook constanten, default methodes, statische methodes en geneste typen bevatten. Methode-bodies bestaan alleen voor default en statische methodes.

Een interface schrijven is vergelijkbaar met een klasse schrijven. Maar een klasse beschrijft de attributen en gedragingen van een object. Een interface bevat gedragingen die een klasse implementeert.

Tenzij de klasse die de interface implementeert abstract is, moeten alle methodes van de interface in de klasse gedefinieerd worden.

Vergelijking: Interface vs Klasse

Een interface is op de volgende manieren vergelijkbaar met een klasse:

• Een interface kan elk aantal methodes bevatten.
• Een interface wordt in een bestand met een .java-extensie geschreven, met de naam van de interface die overeenkomt met de bestandsnaam.
• De bytecode van een interface verschijnt in een .class-bestand.
• Interfaces verschijnen in packages, en hun bijbehorende bytecode-bestand moet in een directorystructuur staan die overeenkomt met de packagenaam.

Echter, een interface verschilt op verschillende manieren van een klasse:

• Je kunt een interface niet instantiëren.
• Een interface bevat geen constructors.
• Alle methodes in een interface zijn abstract (implíciet).
• Een interface kan geen instancevelden bevatten. De enige velden die in een interface mogen verschijnen, moeten zowel static als final zijn.
• Een interface wordt niet uitgebreid (extended) door een klasse; het wordt geïmplementeerd (implemented) door een klasse.
• Een interface kan meerdere interfaces uitbreiden.

Interfaces Declareren

Het interface-sleutelwoord wordt gebruikt om een interface te declareren.

Voorbeeld

/* Bestandsnaam: NameOfInterface.java */
import java.lang.*; // Elk aantal import statements
public interface NameOfInterface {
    // Elk aantal final, static velden
    // Elk aantal abstracte methode-declaraties
}

Interfaces hebben de volgende eigenschappen:

• Een interface is implíciet abstract. Je hoeft het abstract-sleutelwoord niet te gebruiken bij het declareren van een interface.
• Elke methode in een interface is ook implíciet abstract, dus het abstract-sleutelwoord is niet nodig.
• Methodes in een interface zijn implíciet public.

Voorbeeld: Dier Interface

/* Bestandsnaam: Animal.java */
interface Animal {
    public void eat();
    public void travel();
}

Interfaces Implementeren

Wanneer een klasse een interface implementeer, kun je de klasse zien als een contract tekenen, akkoord gaand om de specifieke gedragingen van de interface uit te voeren. Als een klasse niet alle gedragingen van de interface uitvoert, moet de klasse zichzelf als abstract declareren.

Een klasse gebruikt het implements-sleutelwoord om een interface te implementeren. Het implements-sleutelwoord verschijnt in de klassedeclaratie na het extends-deel van de declaratie.

Voorbeeld

/* Bestandsnaam: MammalInt.java */
public class MammalInt implements Animal {
    public void eat() {
        System.out.println("Zoogdier eet");
    }
    public void travel() {
        System.out.println("Zoogdier reist");
    }
    public int noOfLegs() { return 0; }
    public static void main(String args[]) {
        MammalInt m = new MammalInt();
        m.eat();
        m.travel();
    }
}

Resultaat:

Zoogdier eet
Zoogdier reist

Regels bij het overschrijven van interface-methodes

• Gecontroleerde uitzonderingen (checked exceptions) mogen niet worden gedeclareerd op implementatiemethodes, behalve die gedeclareerd door de interface-methode of subclasses daarvan.
• De handtekening van de interface-methode en hetzelfde returntype of subtype moet behouden blijven bij het overschrijven.
• Een implementatieklasse kan zelf abstract zijn; in dat hoeven interface-methodes niet geïmplementeerd te worden.

Regels bij het implementeren van interfaces

• Een klasse kan meer dan één interface tegelijk implementeren.
• Een klasse kan slechts één klasse uitbreiden, maar veel interfaces implementeren.
• Een interface kan een andere interface uitbreiden, op dezelfde manier als een klasse een andere klasse kan uitbreiden.

Interfaces Uitbreiden (Extending Interfaces)

Een interface kan een andere interface uitbreiden op dezelfde manier als een klasse een andere klasse kan uitbreiden. Het extends-sleutelwoord wordt gebruikt om een interface uit te breiden, en de child-interface overneemt de methodes van de parent-interface.

Voorbeeld: Sports, Football, Hockey

// Bestandsnaam: Sports.java
public interface Sports {
    public void setHomeTeam(String name);
    public void setVisitingTeam(String name);
}

// Bestandsnaam: Football.java
public interface Football extends Sports {
    public void homeTeamScored(int points);
    public void visitingTeamScored(int points);
    public void endOfQuarter(int quarter);
}

// Bestandsnaam: Hockey.java
public interface Hockey extends Sports {
    public void homeGoalScored();
    public void visitingGoalScored();
    public void endOfPeriod(int period);
    public void overtimePeriod(int ot);
}

De Hockey-interface heeft vier methodes, maar overneemt twee van Sports; dus een klasse die Hockey implementeert, moet alle zes methodes implementeren. Op dezelfde manier moet een klasse die Football implementeert, de drie methodes van Football en de twee van Sports definiëren.

Meerdere Interfaces Uitbreiden

Een Java-klasse kan slechts één parent-klasse uitbreiden. Multiple inheritance is niet toegestaan. Interfaces zijn echter geen klassen, en een interface kan meer dan één parent-interface uitbreiden.

Het extends-sleutelwoord wordt één keer gebruikt, en de parent-interfaces worden in een komma-gescheiden lijst gedeclareerd.

Voorbeeld

public interface Hockey extends Sports, Event

Tagging Interfaces

Het meest voorkomende gebruik van het uitbreiden van interfaces treedt op wanneer de parent-interface geen methodes bevat. Bijvoorbeeld, de MouseListener-interface in het java.awt.event-pakket breidt java.util.EventListener uit, wat gedefinieerd is als:

package java.util;
public interface EventListener {}

Een interface zonder methodes wordt een tagging-interface genoemd. Er zijn twee basisontewerpdoeleinden van tagging-interfaces:

Creëert een gemeenschappelijke parent – Zoals bij de EventListener-interface, die door tientallen andere interfaces in de Java API wordt uitgebreid, kun je een tagging-interface gebruiken om een gemeenschappelijke parent te creëren onder een groep interfaces. Bijvoorbeeld, wanneer een interface EventListener uitbreidt, weet de JVM dat deze specifieke interface gebruikt zal worden in een event-delegatie-scenario.

Voegt een datatype toe aan een klasse – Dit is de situatie waar de term "tagging" vandaan komt. Een klasse die een tagging-interface implementeert, hoeft geen methodes te definiëren (aangezien de interface er geen heeft), maar de klasse wordt een interface-type door polymorfisme.