"Hallo, Amigo! Ik ben het - alweer. Ik wil je een andere kijk op interfaces geven. Zie je, meestal is een klasse een model van een bepaald object. Interfaces lijken daarentegen meer op de mogelijkheden van een object of rollen, in plaats van het object zelf."

Dingen zoals auto's, fietsen, motorfietsen en wielen kunnen bijvoorbeeld het beste worden weergegeven als klassen en objecten. Maar hun capaciteiten, zoals "Ik kan bewegen", "Ik kan mensen dragen", en "Ik kan parkeren", worden beter weergegeven als interfaces. Bekijk dit voorbeeld:

Java-code Beschrijving 
interface Moveable
{
void move(String newAddress);
}
 Komt overeen met het vermogen om te bewegen. 
interface Driveable
{
void drive(Driver driver);
}
 Komt overeen met het vermogen om te bewegen. 
interface Transport
{
void addStuff(Object stuff);
Object removeStuff();
}
 Komt overeen met het vermogen om vracht te vervoeren. 
class Wheel implements Moveable
{
...
}
 Een «wiel» klasse. Heeft het vermogen om te bewegen. 
class Car implements Moveable, Drivable, Transport
{
...
}
 Een «auto» klasse. Heeft het vermogen om te bewegen, te worden bestuurd door een persoon en vracht te vervoeren. 
class Skateboard implements Moveable, Driveable
{
...
}
 Een «skateboard» klasse. Heeft het vermogen om te bewegen en bestuurd te worden door een persoon.
Java webinar

Interfaces vereenvoudigen het leven van de programmeur aanzienlijk. Programma's hebben vaak duizenden objecten, honderden klassen en slechts een paar dozijn interfaces (rollen). Er zijn weinig rollen, maar ze kunnen op veel manieren gecombineerd worden (klassen).

Het hele punt is dat je geen code hoeft te schrijven die de interactie met elke andere klasse definieert. Het enige wat u hoeft te doen is interactie met rollen (interfaces).

Stel je voor dat je een robotbouwer bent. Je hebt tientallen ondergeschikte robots en elk van hen kan meerdere vaardigheden hebben. Stel dat u dringend een muur moet bouwen. Je neemt gewoon alle robots die kunnen "bouwen" en vertelt ze dat ze de muur moeten bouwen. Het maakt je niet zoveel uit welke robots het doen. Laat het een robotgieter zijn. Als het weet hoe het moet bouwen, laat het dan bouwen.

Hier is hoe het eruit zou zien in code:

Java-code Beschrijving 
static interface WallBuilder
{
void buildWall();
}
 Mogelijkheid om «een muur te bouwen». Begrijpt het commando «bouw een muur» (heeft de juiste methode). 
static class WorkerRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class GuardRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class WateringCan
{
…
}
 Robots die deze vaardigheid/vaardigheid hebben.

Een gieter kan geen muur bouwen (hij implementeert de WallBuilder-interface niet).

 
public static void main(String[] args)
{
 //add all robots to a list
 ArrayList robots = new ArrayList();
 robots.add(new WorkerRobot());
 robots.add(new GuardRobot());
 robots.add(new WateringCan());

 //build a wall if you can
 for (Object robot: robots)
 {
  if (robot instanceof WallBuilder)
  {
   WallBuilder builder = (WallBuilder) robot;
   builder.buildWall();
   }
  }
 }
}
 Hoe geven we het bevel om een ​​muur te bouwen?

"Dat is ongelooflijk interessant. Ik had nooit gedacht dat interfaces zo'n interessant onderwerp zouden kunnen zijn."

"En nog wat! Samen met polymorfisme is het helemaal verbluffend."