Interfaces

„Hallo Amigo! Heute wirst du einiges entdecken. Das Thema für heute – Trommelwirbel, bitte – sind Interfaces.“

„Klar. Ein so schöner Tag, dass ich nach Hause gehe, um ein Bad zu nehmen.“

„Ein Interface ist das Kind von Abstraktion und Polymorphie. Das Interface ist einer abstrakten Klasse sehr ähnlich, in der alle Methoden abstrakt sind. Es wird auf die gleiche Weise wie eine Klasse deklariert, jedoch mit dem Schlüsselwort interface. Hier ein paar Beispiele:“

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

„Interessant. Aber warum brauchen wir Interfaces? Wann werden sie benutzt?“

„Interfaces haben zwei enorme Vorteile gegenüber Klassen:“

1) Trennung der „Methoden-Definitionen“ von den Methoden-Implementierungen.

Ich habe dir bereits gesagt, dass du die Methoden deiner Klasse als public deklarieren musst, wenn du willst, dass andere Klassen diese Methoden aufrufen können. Sollen bestimmte Methoden nur von der eigenen Klasse aus aufrufbar sein, dann müssen sie als private deklariert werden. Mit anderen Worten, wir teilen die Methoden der Klasse in zwei Kategorien auf: „für jeden“ und „nur für mich“.

Mit Interfaces können wir diese Aufteilung noch ausbauen. Wir erstellen eine spezielle „Klasse für jeden“, die eine zweite Klasse „nur für mich“ erbt. Das würde dann ungefähr so aussehen:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

Wir haben unsere Klasse in zwei Teile aufgeteilt: ein Interface und eine Klasse, die das Interface implementiert.

„Und was ist nun der Vorteil?“

„Ein uns dasselbe Interface kann von verschiedenen Klassen implementiert werden (erben). Dabei kann jede Klasse ihr eigenes Verhalten haben. ArrayList und LinkedList sind beispielsweise zwei verschiedene Implementierungen des Interfaces List.“

Auf diese Weise verbergen wir nicht nur die verschiedenen Implementierungen, sondern auch die Klassen, die diese Implementierungen enthalten (wir können einfach überall im Code Interfaces verwenden). So können wir sehr flexibel und direkt während der Programmausführung einige Objekte durch andere ersetzen, wobei das Verhalten eines Objekts ohne das Wissen aller Klassen, die es verwenden, geändert wird.

In Kombination mit der Polymorphie ist dies ein sehr mächtiges Werkzeug. Im Moment ist es absolut nicht offensichtlich, warum wir das tun sollten. Du musst zuerst auf Programme stoßen, die aus Dutzenden oder Hunderten von Klassen bestehen, damit du verstehst, wie Interfaces dein Leben erheblich vereinfachen können.

2) Mehrfachvererbung.

In Java kann jede Klasse nur eine Elternklasse besitzen. In anderen Programmiersprachen können Klassen oft mehrere Elternklassen haben. Das ist sehr praktisch, aber es schafft auch viele Probleme.

Java bietet einen Kompromiss:  Du kannst zwar nicht von mehreren Klassen erben, aber du kannst mehrere Interfaces implementieren. Ein Interface kann mehrere übergeordnete Interfaces haben. Eine Klasse kann mehrere Interfaces implementieren und nur von einer Elternklasse erben.