PHP Academy · Lección

Implementación de interfaces

Defina contratos con interface e impleméntelos en varias clases.

Implementación de interfaces es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

Introducción: interfaces de PHP

Una interfaz define un contrato: una lista de firmas de métodos que las clases que la implementan deben proporcionar. A diferencia de las clases abstractas, una clase puede implementar varias interfaces.

Conceptos clave

Conceptos clave:

Se declara con interface Name {}
Los métodos no tienen cuerpo, solo firmas
Se implementa con implements InterfaceName
Una clase puede implementar varias interfaces

Definición de una interfaz

Ejemplo:

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

La interfaz como tipo

Continuación:

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

Constantes de interfaz

Más información:

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

Una interfaz que extiende otra interfaz

Uso práctico:

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

Inyección de dependencias con interfaces

Avanzado:

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

Patrón

Los patrones comunes de interfaces de PHP se utilizan para resolver de forma clara problemas de diseño recurrentes. Aplíquelos de manera coherente para obtener un código legible y fácil de mantener.

Cuándo utilizarlas

Saber cuándo aplicar las interfaces de PHP es tan importante como saber cómo hacerlo. El uso excesivo genera complejidad; el uso insuficiente genera duplicación.

Ejemplo del mundo real

En las aplicaciones reales, las interfaces de PHP aparecen con frecuencia en frameworks, ORM y capas de servicios. Comprenderlas le prepara para contribuir a proyectos profesionales de PHP.

Errores comunes

Evite estos errores al trabajar con interfaces de PHP:

Las clases pueden implementar varias interfaces, pero solo pueden extender una clase
Las interfaces no pueden tener propiedades ni cuerpos de métodos (excepto los valores predeterminados en PHP 8)
Programe siempre contra una interfaz (un tipo abstracto), no contra una implementación
Use interfaces para permitir la inyección de dependencias y la creación de simulaciones en las pruebas

Comprobación rápida

¿Cuántas interfaces puede implementar simultáneamente una clase de PHP?

Repaso: interfaces de PHP

Resumen:

Las clases pueden implementar varias interfaces, pero solo pueden extender una clase
Las interfaces no pueden tener propiedades ni cuerpos de métodos (excepto los valores predeterminados en PHP 8)
Programe siempre contra una interfaz (un tipo abstracto), no contra una implementación
Use interfaces para permitir la inyección de dependencias y la creación de simulaciones en las pruebas

Preguntas frecuentes

¿La lección «Implementación de interfaces» es gratis?

Sí — el texto completo de «Implementación de interfaces» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Implementación de interfaces»?

Defina contratos con interface e impleméntelos en varias clases. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Implementación de interfaces»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PHP Academy