„Hallo Amigo! Da bin ich – schon wieder. Ich möchte dir Interfaces aus einer anderen Perspektive vorstellen. Meistens ist eine Klasse ein Modell eines bestimmten Objekts. Im Gegensatz dazu sind Interfaces eher wie die Fähigkeiten oder Rollen eines Objekts, nicht wie das Objekt selbst.“

Ein Interface ist mehr als ein Interface. Es ist ein Verhalten. - 1

Zum Beispiel werden Dinge wie Autos, Fahrräder, Motorräder und Reifen am besten als Klassen und Objekte dargestellt. Aber ihre Fähigkeiten, wie „Ich kann mich bewegen“, „Ich kann Menschen tragen“ und „Ich kann parken“, werden besser als Interfaces dargestellt. Sieh dir dieses Beispiel an:

Java-Code Beschreibung
interface Moveable
{
void move(String newAddress);
}
Entspricht der Fähigkeit, sich zu bewegen.
interface Driveable
{
void drive(Driver driver);
}
– Entspricht der Fähigkeit, sich zu bewegen.
interface Transport
{
void addStuff(Object stuff);
Object removeStuff();
}
– Entspricht der Fähigkeit, eine Last zu tragen.
class Wheel implements Moveable
{
...
}
– Eine „Reifen“-Klasse. Hat die Fähigkeit, sich zu bewegen.
class Car implements Moveable, Drivable, Transport
{
...
}
– Eine „Auto“-Klasse. Hat die Fähigkeit, sich zu bewegen, von einer Person gefahren zu werden und eine Last zu tragen.
class Skateboard implements Moveable, Driveable
{
...
}
– Eine „Skateboard“-Klasse. Hat die Fähigkeit, sich zu bewegen und von einer Person gesteuert zu werden.

Interfaces vereinfachen das Leben des Programmierers erheblich. Programme haben sehr oft tausende von Objekten, hunderte von Klassen und nur ein paar Dutzend Interfaces (Rollen). Es gibt nur wenige Rollen, aber sie können auf viele Arten (Klassen) kombiniert werden.

Der Punkt ist, dass du keinen Code schreiben musst, der die Interaktion mit jeder anderen Klasse definiert. Du musst lediglich mit Rollen (Interfaces) interagieren.

Stell dir vor, du bist ein Roboter-Bauarbeiter. Du hast Dutzende von untergebenen Robotern und jeder von ihnen kann mehrere Fähigkeiten haben. Nehmen wir an, du musst unbedingt eine Mauer fertig bauen. Du nimmst einfach alle Roboter, die die Fähigkeit zu „bauen“ haben und ihnen sagen, sie sollen die Mauer bauen. Dir ist es egal, welche Roboter das tun. Es kann auch eine Roboter-Gießkanne sein. Wenn ein Roboter weiß, wie man baut, dann lass ihn bauen.

So würde das im Code aussehen:

Java-Code Beschreibung
static interface WallBuilder
{
void buildWall();
}
– Fähigkeit, „eine Mauer zu bauen“. Versteht den Befehl „baue eine Mauer“ (hat die entsprechende Methode).
static class WorkerRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class GuardRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class WateringCan
{
…
}
– Roboter, die diese Fähigkeit/Fertigkeit haben.

– Eine Gießkanne kann keine Mauer bauen (sie implementiert nicht das WallBuilder-Interface).

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();
   }
  }
 }
}
– Wie geben wir den Befehl zum Bau einer Mauer?

„Das ist wahnsinnig interessant. Ich hätte mir nie träumen lassen, dass Interfaces ein so interessantes Thema sein könnten.“

„Und noch einiges mehr! In Kombination mit der Polymorphie ist das total überwältigend.“