implements

La palabra clave implements en PHP

La palabra clave implements le indica a PHP que una clase acepta cumplir el contrato definido por una interfaz. Una interfaz enumera firmas de métodos (y opcionalmente constantes) pero no cuerpos de método; una clase que la implementa debe proporcionar un cuerpo concreto para cada método que la interfaz declara. Si no lo hace, PHP lanza un error fatal antes de que el programa se ejecute.

Esta página cubre la sintaxis, la implementación de varias interfaces a la vez, las constantes de interfaz, el type hinting contra interfaces, los errores comunes que encontrarás y cómo implements difiere de extends. Si las interfaces son nuevas para ti, comienza con PHP Interfaces y ¿Qué es OOP?.

Sintaxis

interface MyInterface {
  public function doSomething(); // signature only — no body
}

class MyClass implements MyInterface {
  public function doSomething() {
    // the concrete implementation lives here
  }
}

MyClass implements MyInterface es una promesa: "esta clase proporciona una versión funcional de cada método que MyInterface requiere." La interfaz es el qué; la clase es el cómo.

Un ejemplo básico

<?php

interface Animal {
  public function makeSound();
}

class Dog implements Animal {
  public function makeSound() {
    echo "Woof!";
  }
}

class Cat implements Animal {
  public function makeSound() {
    echo "Meow!";
  }
}

$animals = [new Dog(), new Cat()];
foreach ($animals as $animal) {
  $animal->makeSound(); // Output: Woof!Meow!
}

Debido a que tanto Dog como Cat implementan Animal, cualquier código que espera un Animal puede trabajar con cualquiera de los dos sin conocer la clase concreta. Este es el fundamento del polimorfismo en PHP.

Implementar múltiples interfaces

A diferencia de extends (una clase solo puede extender un padre), una clase puede implementar cualquier número de interfaces — sepáralas con comas. La clase debe satisfacer todos los métodos de cada interfaz que lista.

<?php

interface Logger {
  public function log(string $message): void;
}

interface Notifier {
  public function notify(string $message): void;
}

class AlertService implements Logger, Notifier {
  public function log(string $message): void {
    echo "LOG: $message\n";
  }
  public function notify(string $message): void {
    echo "NOTIFY: $message\n";
  }
}

$service = new AlertService();
$service->log("Disk space low");    // Output: LOG: Disk space low
$service->notify("Disk space low"); // Output: NOTIFY: Disk space low

Así es como PHP obtiene los beneficios de la herencia múltiple (compartir varios contratos) sin sus desventajas (implementaciones heredadas ambiguas).

Constantes de interfaz y type hinting

Una interfaz puede declarar constantes, y una clase que la implementa accede a ellas como si fueran propias. El verdadero poder, sin embargo, está en el type hinting: cuando declaras el tipo de un parámetro como la interfaz, se acepta cualquier clase que la implemente — así puedes intercambiar implementaciones libremente.

<?php

interface PaymentGateway {
  const CURRENCY = "USD";
  public function charge(float $amount): bool;
}

class StripeGateway implements PaymentGateway {
  public function charge(float $amount): bool {
    echo "Charging " . self::CURRENCY . " $amount\n";
    return true;
  }
}

// Accepts ANY PaymentGateway, not just StripeGateway
function processPayment(PaymentGateway $gateway, float $amount): void {
  $gateway->charge($amount);
}

processPayment(new StripeGateway(), 49.99); // Output: Charging USD 49.99

También puedes comprobar un objeto contra una interfaz en tiempo de ejecución con instanceof:

var_dump($gateway instanceof PaymentGateway); // bool(true)

Errores comunes y advertencias

• Omitir un método es fatal. Si una clase omite aunque sea un método de la interfaz, PHP lanza Fatal error: Class X contains 1 abstract method and must therefore be declared abstract or implement the remaining methods. La comprobación ocurre en tiempo de compilación, antes de que se ejecute ningún código.
• Las firmas deben ser compatibles. Tu implementación debe respetar los tipos de parámetros y de retorno declarados por la interfaz (puedes ampliar los tipos de parámetros y restringir los de retorno según las reglas de varianza de PHP, pero las incompatibilidades son fatales).
• Los métodos de interfaz son implícitamente public. No puedes implementar un método de interfaz como protected o private.
• Las interfaces pueden extender interfaces. Usa interface B extends A para construir sobre otra interfaz; una clase que implementa B debe satisfacer los métodos de ambas. Ten en cuenta que esto utiliza extends, no implements.

implements vs extends

Estas palabras clave son fáciles de confundir:

Una clase puede hacer ambas cosas a la vez: class Circle extends Shape implements JsonSerializable { ... }. Para detalles sobre herencia, consulta PHP extends y, cuando necesites implementaciones parciales, clases abstractas en PHP.

Cuándo usar implements

Recurre a una interfaz e implements cuando:

• Varias clases no relacionadas necesitan ser intercambiables (por ejemplo, múltiples pasarelas de pago, loggers o controladores de caché).
• Quieres hacer type hinting contra una capacidad en lugar de una clase concreta, manteniendo el código poco acoplado y fácil de probar con mocks.
• Estás definiendo un contrato de API pública que otras clases — incluidas las escritas más adelante o por otros equipos — deben cumplir.

Si en cambio necesitas compartir código de implementación real entre clases relacionadas, usa la herencia de clases (extends) o una clase abstracta.

Práctica