PHP Academy · Lektion

Implementera gränssnitt

Definiera kontrakt med interface och implementera dem i flera klasser.

Lektion 3 av 413 steg

Implementera gränssnitt är en gratis lektion i PHP Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för PHP Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i PHP Academy innehåller totalt 4 lektioner.

Introduktion: PHP-gränssnitt

Ett gränssnitt definierar ett kontrakt: en lista med metodsignaturer som implementerande klasser måste tillhandahålla. Till skillnad från abstrakta klasser kan en klass implementera flera gränssnitt.

Viktiga begrepp

Viktiga begrepp:

  • Deklarera med interface Name {}
  • Metoder har ingen kropp – endast signaturer
  • Implementera med implements InterfaceName
  • En klass kan implementera flera gränssnitt

Definiera ett gränssnitt

Exempel:

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

Gränssnitt som typ

Fortsättning:

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

Gränssnittskonstanter

Fördjupning:

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

Ett gränssnitt som utökar ett annat gränssnitt

Praktisk användning:

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

Beroendeinjektion med gränssnitt

Avancerat:

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

Mönster

Vanliga mönster för PHP-gränssnitt används för att lösa återkommande designproblem på ett tydligt sätt. Tillämpa dem konsekvent för att få läsbar och underhållbar kod.

När det ska användas

Att veta när PHP-gränssnitt ska användas är lika viktigt som att veta hur. Överanvändning leder till komplexitet; underanvändning leder till duplicering.

Exempel från verkligheten

I verkliga applikationer förekommer PHP-gränssnitt ofta i ramverk, ORM:er och servicelager. Genom att förstå dem blir du redo att bidra till professionella PHP-projekt.

Vanliga fallgropar

Undvik dessa misstag med PHP-gränssnitt:

  • Klasser kan implementera flera gränssnitt men bara utöka en klass
  • Gränssnitt kan inte ha egenskaper eller metodkroppar (förutom standardimplementationer i PHP 8)
  • Programmera alltid mot ett gränssnitt (en abstrakt typ), inte mot en implementation
  • Använd gränssnitt för att möjliggöra beroendeinjektion och mocking i tester

Snabb kontroll

Hur många gränssnitt kan en PHP-klass implementera samtidigt?

Sammanfattning: PHP-gränssnitt

Sammanfattning:

  • Klasser kan implementera flera gränssnitt men bara utöka en klass
  • Gränssnitt kan inte ha egenskaper eller metodkroppar (förutom standardimplementationer i PHP 8)
  • Programmera alltid mot ett gränssnitt (en abstrakt typ), inte mot en implementation
  • Använd gränssnitt för att möjliggöra beroendeinjektion och mocking i tester
Gratis att börja

Lär dig PHP med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
49
Lektioner
195

Vanliga frågor

Är lektionen ”Implementera gränssnitt” gratis?

Ja – hela texten till ”Implementera gränssnitt” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i PHP Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i PHP Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera gränssnitt”?

Definiera kontrakt med interface och implementera dem i flera klasser. Ni övar på PHP Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig PHP Academy?

Du behöver inga förkunskaper. Utbildningen i PHP Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Implementera gränssnitt”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här PHP Academy-lektionen?

Ja. Varje PHP Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Utöka klasser med arv
  2. Abstrakta klasser och metoder
  3. Implementera gränssnitt
  4. Traits för kodåteranvändning
← Tillbaka till PHP Academy