Interface

Aus php bar

Mit einem Interface (dt. Schnittstelle) kann man definieren, welche Methoden eine Klasse haben muss. Dies ist vergleichbar mit der Vererbung von Klassen, mit dem Unterschied, dass das Interface keine Eigenschaften besitzt, sondern nur die Methodenköpfe enthält, die dann von der neuen Klasse überschrieben werden müssen.

Allerdings ist es möglich Konstanten zu definieren, die den Klassen, die das Interface implementieren, zur Verfügung stehen. Die Konstanten sind über den Scope Resolution Operator erreichbar.

Ein Interface ist ähnlich einer abstrakten Klasse, welche nur abstrakte Methoden beinhaltet.

Nützlich ist dies, wenn man mehrere Klassen schreibt, die man alle zu einer Kategorie bzw. einer Funktionalität zusammenlegen kann. Ein Beispiel wäre ein Logger-Interface:

1 interface logger {
2     public function open();
3     public function write($msg);
4     public function close();
5 }

1 //  Beispiel eines Interfaces mit Konstanten
2 interface loggingLevels {
3     const NOTICE = '1';
4     const WARNING = '2';
5     const ERROR = '4';
6 }

Dieses Interface kann man nun mit dem Schlüsselwort implements in einer Klasse einbinden lassen.

1  class Logger_MySQL implements logger {
2      public function open() {
3          mysql_connect(/*....*/);
4      }
5      
6      public function write($msg) {
7          mysql_query('INSERT INTO.....');
8      }
9  
10     public function close() {
11         mysql_close();
12     }
13 }

1  class Logger_File implements logger {
2      private $fp;
3      public function open() {
4          $this->fp = fopen(/*....*/);
5      }
6      
7      public function write($msg) {
8          fwrite($msg, $this->fp);
9      }
10 
11     public function close() {
12         fclose($this->fp);
13     }
14 }

1  class Logger_Message implements loggingLevels {
2      
3      private $level = 0;
4  
5      public function setLevel($level) {
6          $this->level = $level;
7      }
8      //... weitere Methoden
9  }
10 
11 $msg = new Logger_Message();
12 $msg->setLevel(Logger_Message::WARNING);

Wie man hier sieht, wurden die Methoden aus dem Interface überschrieben. Man kann nun weitere Logger-Klassen definieren, die alle mindestens die Methoden open(), write() und close() haben. Somit kann man sich sicher sein, dass das Script auch mit einer anderen Logger-Klasse funktioniert, da es die selben Methoden besitzen muss. Dies verringert die Fehlerquelle beim Erstellen von neuen Logger-Klassen.

Ein Vorteil von Interfaces liegt darin, dass eine Klasse mehrere Interfaces implementieren kann:

1 class IOStream implements IStream, OStream
2 {
3    // ...
4 }

Durch die fehlende Mehrfachvererbung von C++ bleibt dem Entwickler jedoch die Schreibarbeit nicht erspart.

Klassen und Objekte (kursiv = veraltet, fett = ab PHP 5)

Bestandteile	Interface, Klasse, Methode, Eigenschaft, Konstante, Konstruktor, Destruktor
Verhalten	Zugriff und Sichtbarkeit, Vererben und Erweitern, Überladen, Abstrahieren, Implementieren, Type Hinting, Klonen und Kopieren
Schlüsselworte	class, function, var, const; implements, extends; parent, self, $this, ::; public, private, protected, static, abstract, final
magische Funktionen	__sleep(), __wakeup(); __construct(), __destruct(); __clone(), __toString(); __call(), __get(), __set()
Funktionen	class_exists(), get_class_methods(), get_class_vars(), get_class(), get_declared_classes(), get_object_vars(), get_parent_class(), is_a(), is_subclass_of(), method_exists(), call_user_func_array(), call_user_func(), clone, __autoload(), get_declared_interfaces(), overload(), aggregate(),
Operatoren	instanceof
PHP-Handbuch-Einträge	Klassen- und Objekt-Funktionen, Klassen und Objekte (PHP 4), Klassen und Objekte (PHP 5)
PHP-Erweiterungen	Classkit, Runkit

Ein Interface kann beispielsweise dann zur Verfügung gestellt werden, wenn mehrere Entwickler an einem Projekt arbeiten. Jeder Programmierer, der dieses Interface implementiert, wird dann gezwungen alle Methoden des Interfaces zu verwenden und auszuprogrammieren (Methoden eines Interfaces sind ja nicht ausprogrammiert, nur die Methoden-Rümpfe sind deklariert). Sonst reklamiert der Compiler. Teilweise kann man aber auch Adapter-Klassen verwenden: Sie implementieren das Interface, man kann dann aber auch nur einzelne Methoden des Interfaces nutzen. Nachteil von Adapter-Klassen: der Compiler (Java) prüft erst zur Laufzeit; ist die Methode falsch geschrieben, wirft der Java-Compiler eine Exception (Fehler).