Interface (Java)

Uit Wikipedia, de vrije encyclopedie

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 statische constanten (met final en static). 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 Java code 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 kan 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.

[bewerk] Gebruik

Een interface in Java heeft de volgende vorm:

zichtbaarheid interface naamInterface [extends naamInterface, 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)
 }

[bewerk] Voorbeeld

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
   }
}