Skip to content

6. Interfaces

Una interfaz es una estructura que define prototipos de métodos. Una clase que implementa una interfaz debe implementar el código de todos los métodos de la interfaz. Una interfaz es un contrato: especifica lo que un objeto puede hacer, sin especificar cómo lo hace.

6.1. Estructura de directorios de los scripts

Los scripts de este capítulo se encuentran en la carpeta [scripts-console/interfaces]:

1
2
3
4
5
6
7
8
php8-oct-2026/scripts-console/interfaces
├── ICalculation.php
├── IExample.php
├── IExample2.php
├── interface-01.php
├── interface-02.php
├── interface-03.php
└── interface-04.php

6.2. Una primera interfaz

Definimos una interfaz llamada [IExample] en un script llamado [IExample.php]. En el mismo script definimos dos clases que implementan la interfaz [IExample]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// una interfaz
interface IExample
{
    // los métodos de la interfaz
    public function add(int $i, int $j): int;

    public function subtract(int $i, int $j): int;
}

// implementación 1 de la interfaz IExample
class Class1 implements IExample
{
    public function add(int $a, int $b): int
    {
        return $a + $b + 10;
    }

    public function subtract(int $a, int $b): int
    {
        return $a - $b + 20;
    }
}

// implementación 2 de la interfaz IExample
class Class2 implements IExample
{
    public function add(int $a, int $b): int
    {
        return $a + $b + 100;
    }

    public function subtract(int $a, int $b): int
    {
        return $a - $b + 200;
    }
}

Comentarios

  • Líneas 10–15: la interfaz [IExample] define dos métodos: la función [add] (línea 13) y la función [subtract] (línea 15). La interfaz no define el código de estos métodos. Lo harán las clases que implementen la interfaz. Los métodos de una interfaz deben ser públicos;
  • línea 19: la clase [Class1] implementa ([implements]) la interfaz [IExample]. Por lo tanto, define el código de los métodos [add] (línea 21) y [subtract] (línea 26). Los nombres de los parámetros pueden diferir de los de la interfaz ([$a] en lugar de [$i]), pero sus tipos deben ser compatibles. Sin embargo, tenga en cuenta que, con los argumentos con nombre de PHP 8, una llamada a [add(i: 1, j: 2)] no funcionaría con [Class1]. Por lo tanto, es preferible conservar los nombres de la interfaz;
  • Líneas 33–44: lo mismo se aplica a la clase [Class2].

Utilizamos la interfaz [IExample] en el siguiente script [interface-01.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión y declaración de las clases e interfaces usadas por el script
require_once __DIR__ . "/IExample.php";
use Examples\Class1;
use Examples\Class2;
use Examples\IExample;

// función
function calculate(int $a, int $b, IExample $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
}

// ─────────────────── main
// creación de 2 objetos de tipo Class1 y Class2
$c1 = new Class1();
$c2 = new Class2();
// llamada a la función calculate
calculate(4, 3, $c1);
calculate(14, 13, $c2);
// una interfaz no puede instanciarse
try {
    new IExample();
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}

Resultados:

1
2
3
4
5
6
> php interface-01.php
17
21
127
201
Error: Cannot instantiate interface Examples\IExample

Comentarios

  • líneas 7–10: inclusión y declaración de las clases e interfaces utilizadas por el script. El archivo [IExample.php] se incluye mediante la instrucción [require_once]: se incluirá una sola vez, aunque varios scripts del proyecto lo incluyan;
  • Líneas 13–17: se define una función;
  • Línea 13: aquí hemos declarado los tipos de los tres parámetros. Si, en tiempo de ejecución, el parámetro real no es del tipo esperado, se lanza un error [TypeError]. El tercer parámetro es de tipo [IExample]. Esto significa que el parámetro real debe ser una instancia de una clase que implemente la interfaz [IExample]; por lo tanto, en nuestro ejemplo, una instancia de las clases [Class1] o [Class2]. La función [calculate] no conoce estas clases; solo reconoce la interfaz. Podemos pasarle objetos de clases escritas más adelante, siempre que implementen la interfaz [IExample];
  • líneas 15–16: utilizamos los métodos [add, subtract] de la interfaz [IExample];
  • línea 24: el tercer parámetro real es de tipo [Class1], que es compatible con el tipo [IExample] del tercer parámetro formal de la función;
  • línea 25: lo mismo se aplica a la clase [Class2];
  • línea 28: una interfaz no puede instanciarse; se devuelve un error (línea 6 de los resultados).

6.3. Derivación de una interfaz

Así como una clase hija puede extender una clase padre, una interfaz hija puede extender una interfaz padre.

Consideremos la interfaz [IExample2] definida en el archivo [IExample2.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// inclusión de la definición de la interfaz IExample
require_once __DIR__ . "/IExample.php";

// una interfaz derivada de IExample
interface IExample2 extends IExample
{
    // el método agregado por la interfaz
    public function multiply(int $i, int $j): int;
}

// implementación de la interfaz IExample2
class Class3 extends Class2 implements IExample2
{
    // [Override] verifica que el método exista realmente en la interfaz
    #[\Override]
    public function multiply(int $a, int $b): int
    {
        return $a * $b;
    }
}

Comentarios

  • línea 7: la interfaz [IExample2] estará en el mismo espacio de nombres que la interfaz [IExample];
  • línea 10: se incluye el archivo de definición de la interfaz [IExample];
  • Líneas 13–17: definen la interfaz [IExample2], que extiende ([extends]) la interfaz [IExample] y le agrega un nuevo método (línea 16). Una interfaz puede incluso extender varias interfaces: [interface I3 extends I1, I2];
  • líneas 20–28: la clase [Class3] extiende la clase [Class2]. Como esta última implementa la interfaz [IExample], la clase [Class3] también lo hará. En efecto, [Class3] hereda todos los métodos públicos y protegidos de la clase [Class2], incluidos los métodos [add] y [subtract] . Además, se especifica que [Class3] implementa la interfaz [IExample2]. Por lo tanto, también debe implementar el método [multiply], lo que [Class2] no hace. Esto es lo que hacen las líneas 24–27;
  • línea 23: a partir de PHP 8.3, el atributo [#[\Override]], tratado en el capítulo anterior, también se aplica a un método que implementa un método de una interfaz. Si el método [multiply] desapareciera de la interfaz [IExample2], PHP lo señalaría.

La interfaz [IExample2] es utilizada por el siguiente script [interface-02.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión y declaración de las clases e interfaces necesarias para el script
require_once __DIR__ . "/IExample2.php";
use Examples\IExample2;
use Examples\Class3;

// función
function calculate(int $a, int $b, IExample2 $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
    print $interface->multiply($a, $b) . "\n";
}

// ─────────────────── main
// creación de 1 objeto de tipo Class3 que implementa IExample2
$c3 = new Class3();
// llamada a la función calculate
calculate(4, 3, $c3);

Resultados:

1
2
3
4
> php interface-02.php
107
201
12

Comentarios

  • Línea 12: el tercer parámetro de la función [calculate] es de tipo [IExample2];
  • Líneas 14–16: se utilizan los tres métodos de la interfaz [IExample2]: los dos heredados de [IExample] y el propio;
  • línea 23: se llama a la función [calculate] con, como tercer parámetro, un objeto de tipo [Class3] que implementa [IExample2] (línea 21).

6.4. Paso de una interfaz como parámetro de una función

Vimos en el capítulo anterior (en la sección “Paso de un objeto como parámetro de una función”) que, cuando el tipo esperado para un parámetro de una función es una clase, el parámetro real puede ser un objeto del tipo esperado o de un tipo derivado. Lo mismo se aplica a las interfaces, como se muestra en el siguiente script, [interface-03.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión y declaración de las clases e interfaces necesarias para el script
require_once __DIR__ . "/IExample.php";
require_once __DIR__ . "/IExample2.php";
use Examples\IExample;
use Examples\IExample2;
use Examples\Class1;
use Examples\Class3;

// función
function calculate(int $a, int $b, IExample $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
}

// ─────────────────── main
// creación de 1 objeto de tipo Class3 que implementa IExample2 y por lo tanto IExample
$c3 = new Class3();
// llamada a la función calculate
calculate(4, 3, $c3);
// el operador [instanceof] prueba si un objeto implementa una interfaz
foreach ([new Class1(), $c3] as $object) {
    print $object::class . ": IExample=" . var_export($object instanceof IExample, true)
        . ", IExample2=" . var_export($object instanceof IExample2, true) . "\n";
}
// las interfaces implementadas por la clase Class3
print_r(class_implements($c3));

Resultados:

> php interface-03.php
107
201
Examples\Class1: IExample=true, IExample2=false
Examples\Class3: IExample=true, IExample2=true
Array
(
    [Examples\IExample] => Examples\IExample
    [Examples\IExample2] => Examples\IExample2
)

Comentarios

  • Línea 15: la función [calculate] espera un tipo [IExample] como tercer parámetro. Esto significa que el parámetro real puede ser de tipo [IExample] o de un tipo derivado;
  • Línea 23: se instancia un objeto de tipo [$c3] a partir de la clase [Class3], que implementa la interfaz [IExample2], la cual a su vez extiende la interfaz [IExample]. Así que, en definitiva, [$c3] implementa la interfaz [IExample];
  • Línea 25: se llama a la función [calculate] con el objeto [$c3] (de tipo [Class3]) como tercer parámetro. Por la herencia de clases y las implementaciones, vimos que el objeto [$c3] implementa el tipo [IExample]. Por lo tanto, podemos usarlo como tercer parámetro;
  • líneas 27–30: el operador [instanceof] comprueba si un objeto implementa una interfaz. Un objeto de tipo [Class1] implementa [IExample] pero no [IExample2] (línea 4 de los resultados). Un objeto de tipo [Class3] implementa ambas (línea 5);
  • línea 32: la función [class_implements] devuelve la lista de interfaces implementadas por un objeto o una clase, ya sea directamente o por herencia (líneas 6–10 de los resultados).

6.5. Constantes de interfaz, interfaces múltiples y tipos de intersección

Una interfaz también puede declarar constantes, y una clase puede implementar varias interfaces. Definimos dos interfaces, [ICalculation] e [INameable], y dos clases que las implementan en el archivo [ICalculation.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// una interfaz puede declarar constantes
interface ICalculation
{
    // constante tipada (PHP 8.3)
    public const int PRECISION = 2;

    public function calculate(float $a, float $b): float;
}

// una segunda interfaz
interface INameable
{
    public function getName(): string;
}

// una clase puede implementar varias interfaces
final class Addition implements ICalculation, INameable
{
    #[\Override]
    public function calculate(float $a, float $b): float
    {
        return round($a + $b, self::PRECISION);
    }

    #[\Override]
    public function getName(): string
    {
        return "addition";
    }
}

final class Division implements ICalculation, INameable
{
    #[\Override]
    public function calculate(float $a, float $b): float
    {
        // [ICalculation::PRECISION] y [self::PRECISION] se refieren a la misma constante
        return round($a / $b, ICalculation::PRECISION);
    }

    #[\Override]
    public function getName(): string
    {
        return "division";
    }
}

Comentarios

  • línea 13: la interfaz [ICalculation] declara una constante. Todas las clases que implementan la interfaz la heredan. A partir de PHP 8.3, una constante de clase o de interfaz puede tener tipo (aquí, [int]);
  • Líneas 19–22: una segunda interfaz, con un único método;
  • línea 25: la clase [Addition] implementa ambas interfaces: los nombres de las interfaces se separan con comas. Debe definir los métodos de las dos;
  • línea 30: se accede a la constante heredada de la interfaz mediante [self::PRECISION]. La función [round] redondea un número al número de decimales especificado;
  • línea 46: también se puede hacer referencia a la constante mediante el nombre de la interfaz: [ICalculation::PRECISION].

Estas interfaces son utilizadas por el script [interface-04.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión y declaración de las clases e interfaces necesarias para el script
require_once __DIR__ . "/ICalculation.php";
use Examples\ICalculation;
use Examples\INameable;
use Examples\Addition;
use Examples\Division;

// el parámetro [$calculation] tiene un valor por defecto: un objeto creado con [new] (PHP 8.1)
function execute(float $a, float $b, ICalculation $calculation = new Addition()): float
{
    return $calculation->calculate($a, $b);
}

// tipo intersección (PHP 8.1): [$operation] debe implementar ambas interfaces
function display(float $a, float $b, ICalculation&INameable $operation): void
{
    print $operation->getName() . "($a, $b)=" . $operation->calculate($a, $b) . "\n";
}

// ─────────────────── main
// constante de la interfaz
print "precision: " . ICalculation::PRECISION . " decimal places\n";
// valor por defecto del 3.er parámetro
print "execute(1.234, 2.345)=" . execute(1.234, 2.345) . "\n";
// parámetro explícito
print "execute(10, 3, new Division())=" . execute(10, 3, new Division()) . "\n";
// tipo intersección
display(10, 4, new Division());
display(10, 4, new Addition());
// las clases implementan ambas interfaces
print_r(class_implements(Division::class));

Resultados:

> php interface-04.php
precision: 2 decimal places
execute(1.234, 2.345)=3.58
execute(10, 3, new Division())=3.33
division(10, 4)=2.5
addition(10, 4)=14
Array
(
    [Examples\ICalculation] => Examples\ICalculation
    [Examples\INameable] => Examples\INameable
)

Comentarios

  • Línea 14: el tercer parámetro de la función [execute] es de tipo [ICalculation] y tiene un valor por defecto: un objeto [Addition] creado con [new]. Hasta PHP 8.0, el valor por defecto de un parámetro solo podía ser una constante. A partir de PHP 8.1, la expresión [new] se acepta en los valores por defecto de los parámetros (“new in initializers”), así como en los argumentos de los atributos de PHP ([#[...]]), las variables estáticas y las constantes globales. Sigue estando prohibida en el valor por defecto de un atributo de clase. El objeto se crea en cada llamada que omite el parámetro;
  • línea 20: el tipo [ICalculation&INameable] es un tipo de intersección (PHP 8.1): el parámetro real debe implementar tanto [ICalculation] como [INameable]. La función puede entonces llamar a métodos de ambas interfaces. No debe confundirse con el tipo de unión [ICalculation|INameable] (uno u otro);
  • línea 27: la constante es accesible desde fuera mediante el nombre de la interfaz (línea 2 de los resultados);
  • línea 29: se omite el tercer parámetro; es un objeto [Addition] el que realiza el cálculo (línea 3);
  • línea 31: se pasa explícitamente un objeto [Division] (línea 4). Observe que los enteros 10 y 3 se aceptan para parámetros de tipo [float] a pesar de la declaración [strict_types=1]: la conversión de un ***[int] a un [float]*** es la única conversión automática permitida en modo estricto;
  • Líneas 33–34: ambas clases implementan las dos interfaces; la función [display] las acepta (líneas 5–6);
  • línea 36: la notación [Division::class] representa el nombre completo de la clase, en este caso [Examples\Division]. La función [class_implements] acepta tanto un nombre de clase como un objeto.

Las interfaces son omnipresentes en el propio PHP. Ya nos hemos encontrado con dos en el capítulo anterior: [Stringable], implementada automáticamente por cualquier clase que tenga un método [__toString], y [JsonSerializable], que permite controlar la codificación JSON de un objeto. En el próximo capítulo veremos la interfaz [Throwable], implementada por todos los errores y excepciones. Una enumeración también puede implementar una interfaz. Por último, veremos más adelante en este curso que las interfaces constituyen la base de la arquitectura en capas de nuestras aplicaciones: cada capa conoce únicamente la interfaz de la capa adyacente.