Interface (Java)

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken

Een interface in de programmeertaal Java is een soort abstracte klasse die een interface aanduidt die klassen kunnen implementeren. Een interface wordt aangeduid met het sleutelwoord interface en bevat alleen ongedefinieerde methoden en/of statische constanten (met final en static).

Overzicht[bewerken]

Een klasse kan een interface implementeren met behulp van implements (vergelijkbaar met extends voor overerving) waarna de ongedefinieerde methoden van de interface in die klasse gedefinieerd moeten worden. Een klasse die een interface implementeert maar die niet alle methoden definieert, kan omgezet worden in een abstracte klasse door het sleutelwoord abstract toe te voegen - de ongedefinieerde methoden moeten dan in een subklasse gedefinieerd worden.

Aangezien interfaces abstract zijn, is het niet mogelijk objecten te maken van een interface. Het gebruik van een interface in Javacode (bijvoorbeeld als type van een parameter) verwijst naar null of een klasse die de betreffende interface implementeert. Het sleutelwoord abstract hoeft niet voor de ongedefinieerde methoden gezet te worden aangezien alle methoden in een interface per definitie abstract zijn.

Een klasse kan meerdere interfaces implementeren maar alleen van één klasse (rechtstreeks) overerven. Een verschil met abstracte klassen is dat een abstracte klasse wel gedefinieerde methoden kan bevatten maar een interface bevat alleen ongedefinieerde methoden. Verder kan een interface niet andere interfaces implementeren maar wel overerven van een andere interface waardoor subinterfaces gemaakt kunnen worden.

Gebruik[bewerken]

Een interface in Java heeft de volgende vorm:

zichtbaarheid interface naamInterface [extends naamInterface] {
  declaraties van constanten
  declaraties van ongedefinieerde methoden
}

en een interface kan op de volgende manier gebruikt worden, waarbij de namen van meerdere interfaces door komma's gescheiden worden:

 zichtbaarheid class naamKlasse implements naamInterface, naamInterface, ... {
   implementaties van methoden in interface(s)
 }

Voorbeeld[bewerken]

In het volgende voorbeeld definiëren we een interface Verplaatsbaar die door klassen geïmplementeerd kan worden. Deze interface bevat de methode verplaats die aangeeft hoe een object verplaatst kan worden. Deze methode moet door de implementerende klassen, zoals Voetbal of Auto, uitgewerkt worden aangezien deze kan verschillen per object.

public interface Verplaatsbaar {
 
   public void verplaats(Richting richting);
}

Het implementeren van deze interface gaat als volgt:

public class Tafel implements Verplaatsbaar {
 
   public void verplaats(Richting richting) {
      // hier wordt geprogrammeerd hoe een tafel verplaatst moet worden
   }
}

Toepassing[bewerken]

Interfaces kunnen gebruikt worden om abstractie toe te voegen aan het ontwerp van software. Bepaalde informatie hoeft niet in het gehele programma bekend te zijn om de applicatie te kunnen laten functioneren.

Voorbeeld[bewerken]

Stel dat een programma informatie kan laden van verschillende plekken, zoals een database, een XML-bestand of een tekstbestand. Als de informatie geladen moet worden, zou men kunnen kijken welke situatie het geval is en vervolgens de bijbehorende code uitvoeren. Het is ook mogelijk om een interface hiervoor te gebruiken:

public interface InformatieLader {
    public Informatie laadInformatie();
}
 
public class DatabaseLader implements InformatieLader {
    public Informatie laadInformatie() {
        // haal de informatie uit een database
    }
}
 
public class XMLLader implements InformatieLader {
    public Informatie laadInformatie() {
        // haal de informatie uit een XML-bestand
    }
}
 
public class TekstLader implements InformatieLader {
    public Informatie laadInformatie() {
        // haal de informatie uit een tekstbestand
    }
}

Op het moment dat de informatie geladen moet worden, hoeft men alleen de methode laadInformatie() aan te roepen voor de beschikbare InformatieLader. Op deze plek in het programma hoeft men dan niet te bepalen vanaf welke plek de informatie geladen wordt: er is een abstractie ingebouwd waardoor men zich nu niet hoeft bezig te houden met de exacte details van het laden van de informatie:

Informatie informatie = informatieLader.laadInformatie();

Vanaf welke plek de informatie geladen wordt, hangt af van welke InformatieLader gebruikt wordt. Het kan zijn dat dit op een heel andere plek in het programma bepaald wordt, bijvoorbeeld bij het inlezen van enkele configuratiebestanden. Door een van de volgende regels te gebruiken, wordt een InformatieLader aangemaakt die de rest van het programma kan gebruiken:

InformatieLader informatieLader = new DatabaseLader(); // 1
InformatieLader informatieLader = new XMLLader();      // 2
InformatieLader informatieLader = new TekstLader();    // 3

Ook kan de werking van de rest van het programma aangepast worden door alleen die regel aan te passen (dat wil zeggen: door een andere InformatieLader te gebruiken, haalt de rest van het programma de informatie opeens vanaf een andere plek).

Externe link[bewerken]