PHP Academy · Les

Interfaces implementeren

Definieer contracten met interface en implementeer ze in meerdere klassen.

Les 3 van 413 stappen

Interfaces implementeren is een gratis PHP Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject PHP Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus PHP Academy bevat in totaal 4 lessen.

Inleiding: PHP-interfaces

Een interface definieert een contract: een lijst met methodesignaturen die implementerende klassen moeten leveren. In tegenstelling tot abstracte klassen kan een klasse meerdere interfaces implementeren.

Kernbegrippen

Belangrijke begrippen:

Declareer een interface met interface Name {}
Methoden hebben geen body — alleen signaturen
Implementeer een interface met implements InterfaceName
Een klasse kan meerdere interfaces implementeren

Een interface definiëren

Voorbeeld:

<?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 type

Vervolg:

<?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;
}

Interfaceconstanten

Meer diepgang:

<?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() => []);

Een interface uitbreiden met een interface

Praktisch gebruik:

<?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 { }
}

Afhankelijkheidsinjectie met interfaces

Geavanceerd:

<?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.');
    }
}

Patroon

Veelgebruikte patronen voor PHP-interfaces worden gebruikt om terugkerende ontwerpproblemen op een overzichtelijke manier op te lossen. Pas ze consequent toe voor leesbare, onderhoudbare code.

Wanneer gebruik je het

Weten wanneer je PHP-interfaces moet toepassen is net zo belangrijk als weten hoe. Overmatig gebruik leidt tot complexiteit; te weinig gebruik leidt tot duplicatie.

Praktijkvoorbeeld

In echte toepassingen komen PHP-interfaces vaak voor in frameworks, ORM's en servicelagen. Als je dit begrijpt, ben je beter voorbereid om bij te dragen aan professionele PHP-projecten.

Veelvoorkomende valkuilen

Vermijd deze fouten met PHP-interfaces:

Klassen kunnen meerdere interfaces implementeren, maar slechts één klasse uitbreiden
Interfaces kunnen geen eigenschappen of method bodies bevatten (behalve standaardimplementaties in PHP 8)
Programmeert altijd tegen een interface (abstract type) en niet tegen een implementatie
Gebruik interfaces om afhankelijkheidsinjectie en mocken in tests mogelijk te maken

Snelle controle

Hoeveel interfaces kan een PHP-klasse tegelijk implementeren?

Beantwoord dit in de interactieve les

Samenvatting: PHP-interfaces

Samenvatting:

Klassen kunnen meerdere interfaces implementeren, maar slechts één klasse uitbreiden
Interfaces kunnen geen eigenschappen of method bodies bevatten (behalve standaardimplementaties in PHP 8)
Programmeert altijd tegen een interface (abstract type) en niet tegen een implementatie
Gebruik interfaces om afhankelijkheidsinjectie en mocken in tests mogelijk te maken

Gratis beginnen

Leer PHP met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 49
Lessen: 195

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Interfaces implementeren” gratis?

Ja — de volledige tekst van “Interfaces implementeren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus PHP Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus PHP Academy bevat in totaal 4 lessen.

Wat leer ik in “Interfaces implementeren”?

Definieer contracten met interface en implementeer ze in meerdere klassen. Je oefent met PHP Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met PHP Academy te beginnen?

Ervaring vooraf is niet nodig. PHP Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Interfaces implementeren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over PHP Academy?

Ja. Elke les over PHP Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar PHP Academy