PHP Academy · Lektion

Interfaces implementieren

Definieren Sie mit interface Verträge und implementieren Sie sie in mehreren Klassen.

Interfaces implementieren ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Einführung: PHP-Interfaces

Ein Interface definiert einen Vertrag: eine Liste von Methodensignaturen, die implementierende Klassen bereitstellen müssen. Anders als bei abstrakten Klassen kann eine Klasse mehrere Interfaces implementieren.

Wichtige Konzepte

Wichtige Konzepte:

Mit interface Name {} deklarieren
Methoden haben keinen Rumpf – nur Signaturen
Mit implements InterfaceName implementieren
Eine Klasse kann mehrere Interfaces implementieren

Definieren eines Interfaces

Beispiel:

<?php
interface Serializable {
    public function serialize(): string;
    public function unserialize(string $data): void;
}

interface Loggable {
    public function toLog(): string;
}

// Implementing both interfaces:
class Event implements Serializable, Loggable {
    public function __construct(private string $type, private string $data) {}
    public function serialize(): string { return json_encode(['type'=>$this->type,'data'=>$this->data]); }
    public function unserialize(string $d): void { $a = json_decode($d,true); $this->type=$a['type']; $this->data=$a['data']; }
    public function toLog(): string { return "[{$this->type}] {$this->data}"; }
}

Interface als Typ

Fortsetzung:

<?php
interface Cache {
    public function get(string $key): mixed;
    public function set(string $key, mixed $val, int $ttl = 0): void;
    public function delete(string $key): void;
}

// Function accepts any Cache implementation:
function loadUser(int $id, Cache $cache): array {
    $key = "user:$id";
    $user = $cache->get($key);
    if (!$user) {
        $user = fetchFromDb($id);
        $cache->set($key, $user, 3600);
    }
    return $user;
}

Interface-Konstanten

Weitere Vertiefung:

<?php
interface HttpMethods {
    const GET    = 'GET';
    const POST   = 'POST';
    const PUT    = 'PUT';
    const DELETE = 'DELETE';
}

class Router implements HttpMethods {
    public function addRoute(string $method, string $path, callable $handler): void {
        // ...
    }
}

$router = new Router();
$router->addRoute(HttpMethods::GET, '/users', fn() => []);

Interface erweitert Interface

Praktische Anwendung:

<?php
interface Readable {
    public function read(): string;
}

interface Writable {
    public function write(string $data): void;
}

// Interface can extend multiple interfaces:
interface ReadWrite extends Readable, Writable {
    public function seek(int $position): void;
}

class FileStream implements ReadWrite {
    public function read(): string    { return ''; }
    public function write(string $d): void { }
    public function seek(int $p): void { }
}

Dependency Injection mit Interfaces

Fortgeschrittenes Thema:

<?php
interface MailerInterface {
    public function send(string $to, string $subject, string $body): bool;
}

class SmtpMailer implements MailerInterface {
    public function send(string $to, string $subject, string $body): bool {
        // real SMTP send
        return true;
    }
}

class UserService {
    public function __construct(private MailerInterface $mailer) {}

    public function register(string $email): void {
        // save user...
        $this->mailer->send($email, 'Welcome!', 'Thanks for joining.');
    }
}

Muster

Gängige Muster für PHP-Interfaces helfen dabei, wiederkehrende Entwurfsprobleme sauber zu lösen. Wenden Sie sie konsequent an, damit Ihr Code lesbar und wartbar bleibt.

Wann Sie es verwenden sollten

Zu wissen, wann Sie PHP-Interfaces einsetzen sollten, ist ebenso wichtig wie zu wissen, wie sie funktionieren. Übermäßiger Einsatz führt zu Komplexität, zu geringer Einsatz zu Duplikation.

Praxisbeispiel

In realen Anwendungen finden sich PHP-Interfaces häufig in Frameworks, ORMs und Service-Schichten. Wenn Sie sie verstehen, sind Sie gut darauf vorbereitet, an professionellen PHP-Projekten mitzuwirken.

Häufige Fehler

Vermeiden Sie diese Fehler bei PHP-Interfaces:

Klassen können mehrere Interfaces implementieren, aber nur eine Klasse erweitern
Interfaces können keine Eigenschaften oder Methodenrümpfe enthalten (außer Default-Implementierungen in PHP 8)
Programmieren Sie immer gegen ein Interface (einen abstrakten Typ), nicht gegen eine Implementierung
Verwenden Sie Interfaces, um Dependency Injection und Mocking in Tests zu ermöglichen

Schnelltest

Wie viele Interfaces kann eine PHP-Klasse gleichzeitig implementieren?

Zusammenfassung: PHP-Interfaces

Zusammenfassung:

Klassen können mehrere Interfaces implementieren, aber nur eine Klasse erweitern
Interfaces können keine Eigenschaften oder Methodenrümpfe enthalten (außer Default-Implementierungen in PHP 8)
Programmieren Sie immer gegen ein Interface (einen abstrakten Typ), nicht gegen eine Implementierung
Verwenden Sie Interfaces, um Dependency Injection und Mocking in Tests zu ermöglichen

Häufig gestellte Fragen

Ist die Lektion „Interfaces implementieren“ kostenlos?

Ja — der vollständige Text von „Interfaces implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Interfaces implementieren“?

Definieren Sie mit interface Verträge und implementieren Sie sie in mehreren Klassen. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Interfaces implementieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu PHP Academy