Czym jest interface w programowaniu obiektowym?

Interfejs w programowaniu obiektowym to specjalny typ, który definiuje zbiór metod, jakie muszą zostać zaimplementowane przez klasy go implementujące. Jest kluczowym elementem w OOP (programowaniu obiektowym), ponieważ umożliwia tworzenie wspólnego zestawu zachowań dla różnych klas, niezależnie od ich hierarchii dziedziczenia.

Interfejs zawiera tylko deklaracje metod, bez ich implementacji (brak ciała metod). Klasy, które go implementują, muszą dostarczyć konkretne rozwiązania dla każdej z zdefiniowanych metod.

Brak stanu

Interfejsy nie mogą przechowywać stanu (nie zawierają zmiennych instancyjnych), ale mogą definiować stałe.

Wielokrotne dziedziczenie

Klasa może implementować wiele interfejsów jednocześnie, co pozwala na wielokrotne dziedziczenie zachowań. Jest to istotna różnica w porównaniu do dziedziczenia klas, gdzie klasa może dziedziczyć tylko po jednej klasie bazowej (jest pewien trick w PHP -do wielokrotnego dziedziczenia w PHP można użyć trait), ale może implementować wiele interfejsów, co daje większą elastyczność.

Po co używa się interfejsów?

Abstrakcja

Interfejsy umożliwiają tworzenie bardziej abstrakcyjnych i elastycznych aplikacji. Możesz definiować interfejsy dla różnych grup zachowań, co ułatwia zarządzanie kodem i jego rozszerzalność.

Polimorfizm

Dzięki interfejsom możemy osiągnąć polimorfizm, co oznacza, że różne klasy mogą być traktowane jako instancje tego samego interfejsu. Umożliwia to pisanie kodu, który działa z obiektami różnych klas w jednakowy sposób.

Separacja odpowiedzialności

Interfejsy pomagają w separacji odpowiedzialności, co prowadzi do bardziej modularnego kodu. Możesz zmieniać implementacje interfejsów bez wpływu na inne części systemu.

Testowanie

Interfejsy ułatwiają testowanie jednostkowe, ponieważ możemy tworzyć “mocki” (zastępcze implementacje) dla interfejsów. To pozwala na izolowanie testowanych komponentów i symulowanie zachowań.

Załóżmy, że mamy aplikację, która komunikuje się z zewnętrzną usługą, np. API do wysyłania e-maili. W testach nie chcemy faktycznie wysyłać e-maili, więc możemy stworzyć mock obiektu, który implementuje interfejs, aby symulować wysyłanie e-maila. Zobacz na przykładzie:

interface EmailSender {
    public function sendEmail(string $recipient, string $subject, string $message): bool;
}

class RealEmailSender implements EmailSender 
{
    public function sendEmail(string $recipient, string $subject, string $message): bool {
        // Logika wysyłania e-maila, np. użycie PHPMailer lub innej biblioteki
        echo "Sending email to $recipient...";
        return true;
    }
}

class UserNotifier 
{
    private EmailSender $emailSender;

    public function __construct(EmailSender $emailSender) {
        $this->emailSender = $emailSender;
    }

    public function notifyUser(string $email, string $message): bool {
        return $this->emailSender->sendEmail($email, "Notification", $message);
    }
}

class UserNotifierTest extends TestCase 
{
    public function testNotifyUser() {
        // Tworzymy mock obiektu EmailSender
        $emailSenderMock = $this->createMock(EmailSender::class);

        // Ustalamy oczekiwanie, że metoda sendEmail zostanie wywołana raz i zwróci true
        $emailSenderMock->expects($this->once())
                        ->method('sendEmail')
                        ->with('[email protected]', 'Notification', 'Hello!')
                        ->willReturn(true);

        // Tworzymy obiekt UserNotifier z mockowanym EmailSender
        $notifier = new UserNotifier($emailSenderMock);

        // Testujemy metodę notifyUser
        $result = $notifier->notifyUser('[email protected]', 'Hello!');

        // Sprawdzamy, czy zwróciła true (czyli czy powiadomienie zostało "wysłane")
        $this->assertTrue($result);
    }
}

Rozszerzalność

Interfejsy umożliwiają łatwe dodawanie nowych funkcjonalności do aplikacji. Możesz dodać nowe klasy implementujące istniejący interfejs bez konieczności zmiany istniejącego kodu.

Przykład interfejsu w PHP

Oto przykład, jak można zdefiniować interfejs w PHP. Załóżmy, że urządzenie wielofunkcyjne może drukować, skanować i kopiować. Użyjemy trzech interfejsów: Printable dla drukowania, Scannable dla skanowania i Copyable dla kopiowania. Urządzenie, które to wszystko potrafi, będzie implementować wszystkie trzy interfejsy.

// Interfejs dla urządzeń, które mogą drukować
interface Printable {
    public function printDocument(): void;
}

// Interfejs dla urządzeń, które mogą skanować
interface Scannable {
    public function scanDocument(): void;
}

// Interfejs dla urządzeń, które mogą kopiować
interface Copyable {
    public function copyDocument(): void;
}

// Klasa reprezentująca urządzenie wielofunkcyjne, 
// które implementuje wszystkie trzy interfejsy
class MultifunctionPrinter implements Printable, Scannable, Copyable 
{
    // Implementacja metody drukowania
    public function printDocument(): void {
        echo "Printing document...\n";
    }

    // Implementacja metody skanowania
    public function scanDocument(): void {
        echo "Scanning document...\n";
    }

    // Implementacja metody kopiowania
    public function copyDocument(): void {
        echo "Copying document...\n";
    }
}

// Użycie klasy MultifunctionPrinter
$printer = new MultifunctionPrinter();
$printer->printDocument(); // Output: Printing document...
$printer->scanDocument();  // Output: Scanning document...
$printer->copyDocument();  // Output: Copying document...

Urządzenie wielofunkcyjne to świetny przykład użycia wielu interfejsów w programowaniu. Podobnie jak w prawdziwym życiu, jedno urządzenie może pełnić wiele funkcji (drukowanie, skanowanie, kopiowanie), w programowaniu jedna klasa może implementować różne interfejsy, aby dostarczać różne funkcje.

Interfejsy a wzorce projektowe

Interfejsy są często używane razem ze wzorcami projektowymi, ponieważ pomagają w separacji logiki i zwiększają elastyczność kodu. Oto kilka wzorców projektowych, które często korzystają z interfejsów:

Factory Method

Interfejs może być używany do tworzenia obiektów o wspólnym interfejsie, ale różniących się implementacjach.

interface Transport 
{
    public function deliver(): string;
}

class Truck implements Transport 
{
    public function deliver(): string {
        return "Dostarczenie ciężarówką";
    }
}

class Ship implements Transport 
{
    public function deliver(): string {
        return "Dostarczenie statkiem";
    }
}

class Logistics 
{
    public function createTransport(string $type): Transport {
        return match ($type) {
            'land' => new Truck(),
            'sea'  => new Ship(),
            default => throw new InvalidArgumentException('Nieprawidłowy typ transportu.'),
        };
    }
}

$logistics = new Logistics();
$transport = $logistics->createTransport('land');
$transport->deliver(); // Wywoła metodę Truck::deliver

Strategy

Dzięki interfejsowi możemy łatwo wymieniać algorytmy w czasie działania.

interface PaymentMethod {
    public function pay(float $amount): string;
}

class CreditCardPayment implements PaymentMethod 
{
    public function pay(float $amount): string {
        return "Płacenie kartą kredytową: $amount";
    }
}

class PayPalPayment implements PaymentMethod 
{
    public function pay(float $amount): string {
        return "Płacenie przez PayPal: $amount";
    }
}

class PaymentProcessor 
{
    private PaymentMethod $paymentMethod;

    public function __construct(PaymentMethod $paymentMethod) {
        $this->paymentMethod = $paymentMethod;
    }

    public function process(float $amount) {
        $this->paymentMethod->pay($amount);
    }
}

// Przykład użycia:
$processor = new PaymentProcessor(new CreditCardPayment());
$processor->process(100); // Płacenie kartą kredytową

$processor = new PaymentProcessor(new PayPalPayment());
$processor->process(200); // Płacenie przez PayPal

Podsumowanie

Interfejsy są potężnym narzędziem w programowaniu obiektowym, które pozwalają na bardziej strukturalne i elastyczne podejście do projektowania systemów. Dzięki nim można tworzyć kod, który jest łatwiejszy w utrzymaniu, testowaniu i rozbudowie.