interface

La palabra clave interface en PHP

Una interfaz es un contrato: enumera los métodos que una clase debe proporcionar, sin indicar cómo funcionan. Cualquier clase que implements la interfaz se compromete a definir todos los métodos que esta declara. Esto permite programar contra una capacidad ("cualquier cosa que pueda registrarse", "cualquier cosa que pueda serializarse") en lugar de contra una clase concreta.

Las interfaces no pueden instanciarse directamente — no hay implementación que ejecutar. Existen para que clases no relacionadas puedan tratarse de forma intercambiable siempre que compartan las mismas firmas de métodos.

Esta página cubre cómo declarar una interfaz, implementar una o varias, compartir constantes, extender interfaces y verificar tipos en tiempo de ejecución con instanceof. Si eres nuevo en los objetos en PHP, comienza con clases y objetos en PHP y qué es la OOP.

Sintaxis

Esta es la sintaxis básica para declarar una interfaz:

interface MyInterface {
  public function someMethod();
}

Esto declara una interfaz MyInterface con un único método someMethod(). Reglas clave:

• Los cuerpos de los métodos se omiten — una interfaz solo declara firmas, terminando cada una con un punto y coma.
• Todos los métodos son implícitamente public; puedes escribir public por claridad, pero no se permite ninguna otra visibilidad (private/protected están prohibidos).
• Una clase adopta una interfaz con la palabra clave implements y debe definir todos los métodos, o PHP genera un error fatal.

Ejemplos

Veamos algunos ejemplos prácticos de cómo puede usarse la palabra clave interface. La primera clase implementa una interfaz; la segunda implementa dos a la vez (separadas por comas):

<?php

// Example 1
interface MyInterface {
  public function someMethod();
}
class MyClass implements MyInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
}

$obj = new MyClass();
$obj->someMethod();

// Output: This is from someMethod.

// Example 2
interface MyOtherInterface {
  public function someOtherMethod();
}
class MyOtherClass implements MyInterface, MyOtherInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
  public function someOtherMethod() {
    echo "This is from someOtherMethod." . PHP_EOL;
  }
}

$obj2 = new MyOtherClass();
$obj2->someMethod();
$obj2->someOtherMethod();

// Output:
// This is from someMethod.
// This is from someOtherMethod.

En estos ejemplos, definimos interfaces y las usamos en nuestras clases PHP para garantizar que implementen los métodos requeridos.

Constantes de interfaz

Una interfaz puede declarar constantes que cada clase implementadora hereda. Son siempre públicas y no pueden sobreescribirse, lo que las hace útiles para valores fijos compartidos:

<?php

interface HttpStatus {
  const OK = 200;
  const NOT_FOUND = 404;
}

class Response implements HttpStatus {
  public function describe(): string {
    return "Status " . self::OK;
  }
}

echo (new Response())->describe() . PHP_EOL;
echo HttpStatus::NOT_FOUND . PHP_EOL;

// Output:
// Status 200
// 404

Para constantes que sí pueden sobreescribirse, usa constantes de clase dentro de una clase.

Extender interfaces

A diferencia de las clases, una interfaz puede extend múltiples otras interfaces. La interfaz combinada entonces requiere todos los métodos de cada padre:

<?php

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

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

// A single interface that demands both capabilities
interface ReadWrite extends Readable, Writable {}

class File implements ReadWrite {
  private string $buffer = "";
  public function read(): string { return $this->buffer; }
  public function write(string $data): void { $this->buffer = $data; }
}

$f = new File();
$f->write("hello");
echo $f->read() . PHP_EOL;

// Output: hello

Así es como PHP simula la herencia múltiple — consulta herencia en PHP para la herencia de clase única con extends.

Type hints e instanceof

Dado que cualquier clase implementadora satisface la interfaz, puedes indicar el tipo de la interfaz en las firmas de funciones y aceptar cualquier objeto que coincida. Usa instanceof para verificar en tiempo de ejecución:

<?php

interface Shape {
  public function area(): float;
}

class Circle implements Shape {
  public function __construct(private float $r) {}
  public function area(): float { return 3.14159 * $this->r ** 2; }
}

function printArea(Shape $shape): void {
  echo round($shape->area(), 2) . PHP_EOL;
}

$c = new Circle(2);
printArea($c);
var_dump($c instanceof Shape);

// Output:
// 12.57
// bool(true)

Interfaz vs. clase abstracta

Ambas definen un contrato, pero resuelven problemas distintos:

• Una interfaz declara únicamente firmas de métodos y una clase puede implementar muchas de ellas. Úsala para describir una capacidad compartida por clases no relacionadas.
• Una clase abstracta puede proporcionar métodos y propiedades concretos además de abstractos, pero una clase solo puede extender una. Úsala para compartir implementación entre clases relacionadas.

Cuando necesites compartir código entre clases sin herencia, recurre a los traits.

Ventajas

El uso de la palabra clave "interface" tiene varias ventajas, entre ellas:

• Desacoplamiento y flexibilidad: Las interfaces permiten intercambiar implementaciones sin modificar el código dependiente, haciendo el sistema más adaptable.
• Pruebas más sencillas: Permiten el uso de mocks y stubs, lo que simplifica las pruebas unitarias y la depuración.
• Simular herencia múltiple: Dado que PHP no admite la herencia múltiple de clases, una clase puede implementar múltiples interfaces para heredar contratos de comportamiento de varias fuentes.

Conclusión

La palabra clave interface permite definir un contrato de métodos requeridos que cualquier clase puede implementar, independientemente de su lugar en la jerarquía de clases. Combinadas con type hints e instanceof, las interfaces hacen que el código sea más flexible, comprobable y desacoplado. Recurre a una interfaz cuando quieras describir una capacidad; recurre a una clase abstracta cuando también necesites compartir implementación.

Práctica