Bienvenido a una nueva lección de nuestro curso básico de PHP 8. Hoy nos metemos con las interfaces, una herramienta poderosa de la programación orientada a objetos (POO) que te ayuda a definir reglas claras para tus clases. Si ya manejas clases abstractas y polimorfismo, esto te va a encantar porque es como un pacto entre clases. Todo va a ser claro, práctico y con ejemplos que te van a flipar. ¡Empecemos!

¿Qué son las interfaces?

Una interfaz es como un contrato: dice qué métodos debe tener una clase, pero no cómo implementarlos. Es una forma de asegurar que clases diferentes (aunque no estén relacionadas por herencia) tengan un comportamiento común. Por ejemplo, tanto un coche como un avión pueden «moverse», y una interfaz garantiza que ambos tengan un método moverse(), cada uno a su estilo.

Características clave:

• Solo métodos públicos: Todos los métodos son public y sin código (solo firmas).
• Sin propiedades: Las interfaces no tienen variables, solo métodos.
• Implementación obligatoria: Si una clase usa una interfaz, debe definir todos sus métodos.
• Polimorfismo: Permite tratar objetos distintos como si fueran del mismo tipo.

La receta básica en PHP es esta:

interface MiInterfaz {
    public function metodo1();
    public function metodo2($parametro);
}

class MiClase implements MiInterfaz {
    public function metodo1() {
        // Código aquí
    }

    public function metodo2($parametro) {
        // Código aquí
    }
}

• interface: Define el contrato.
• implements: Vincula la clase al contrato.

Probando interfaces en acción

¡Manos a la obra! Crea un archivo interfaces.php en curso_php8 (dentro de C:\xampp\htdocs) y prueba esto:

Ejemplo 1: Interfaz Vehículo

<?php
    interface Vehiculo {
        public function obtenerTipo();
        public function cantidadRuedas();
    }

    class Motocicleta implements Vehiculo {
        public function obtenerTipo() {
            return "Scooter";
        }

        public function cantidadRuedas() {
            return 2;
        }

        public function obtenerModelo() {
            return "AM 2020";
        }
    }

    $scooter = new Motocicleta();
    echo "Tipo: " . $scooter->obtenerTipo() . "<br>";
    echo "Ruedas: " . $scooter->cantidadRuedas() . "<br>";
    echo "Modelo: " . $scooter->obtenerModelo() . "<br>";
?>

Abre http://localhost/curso_php8/interfaces.php. Verás:

Tipo: Scooter
Ruedas: 2
Modelo: AM 2020

¿Qué pasó?

• La interfaz Vehiculo obliga a Motocicleta a tener obtenerTipo() y cantidadRuedas().
• Motocicleta añade su propio método obtenerModelo(), porque las clases pueden tener extras.
• Creamos un objeto y usamos todos los métodos.

Ejemplo 2: Interfaces múltiples

<?php
    interface A {
        public function metodo1();
    }

    interface B {
        public function metodo2();
    }

    interface C extends A, B {
        public function metodo3();
    }

    class MiClase implements C {
        public function metodo1() {
            echo "Implementando método 1<br>";
        }

        public function metodo2() {
            echo "Implementando método 2<br>";
        }

        public function metodo3() {
            echo "Implementando método 3<br>";
        }
    }

    $objeto = new MiClase();
    $objeto->metodo1();
    $objeto->metodo2();
    $objeto->metodo3();
?>

Resultado:

Implementando método 1
Implementando método 2
Implementando método 3

¿Qué pasó?

• C hereda de A y B, juntando sus métodos.
• MiClase implementa C, así que debe definir los tres métodos.
• Esto muestra cómo las interfaces pueden combinarse para crear contratos complejos.

Ejemplo práctico

Ejemplo: Interfaz para dispositivos

<?php
    interface Dispositivo {
        public function encender();
        public function apagar();
    }

    class Telefono implements Dispositivo {
        public function encender() {
            echo "El teléfono se enciende.<br>";
        }

        public function apagar() {
            echo "El teléfono se apaga.<br>";
        }
    }

    class Computadora implements Dispositivo {
        public function encender() {
            echo "La computadora inicia.<br>";
        }

        public function apagar() {
            echo "La computadora se apaga.<br>";
        }
    }

    function controlarDispositivo(Dispositivo $dispositivo) {
        $dispositivo->encender();
        $dispositivo->apagar();
    }

    $telefono = new Telefono();
    $computadora = new Computadora();

    controlarDispositivo($telefono);
    controlarDispositivo($computadora);
?>

Resultado:

El teléfono se enciende.
El teléfono se apaga.
La computadora inicia.
La computadora se apaga.

¿Qué pasó?

• Dispositivo define un contrato para encender() y apagar().
• Telefono y Computadora lo implementan de forma distinta.
• controlarDispositivo() usa el contrato para manejar cualquier Dispositivo, mostrando polimorfismo.

Ejercicio para practicar

¡Tu turno a pica código! Ve a curso_php8 y prueba este reto:

1. Interfaz Reproductor
   Crea reproductor.php:

<?php
       interface Reproductor {
           public function reproducir();
           public function pausar();
           public function detener();
       }

       class ReproductorAudio implements Reproductor {
           public function reproducir() {
               echo "Reproduciendo audio...<br>";
           }

           public function pausar() {
               echo "Pausando audio...<br>";
           }

           public function detener() {
               echo "Deteniendo audio.<br>";
           }
       }

       class ReproductorVideo implements Reproductor {
           public function reproducir() {
               echo "Reproduciendo video...<br>";
           }

           public function pausar() {
               echo "Pausando video...<br>";
           }

           public function detener() {
               echo "Deteniendo video.<br>";
           }
       }

       $audio = new ReproductorAudio();
       $video = new ReproductorVideo();

       $audio->reproducir();
       $audio->pausar();
       $audio->detener();

       $video->reproducir();
       $video->pausar();
       $video->detener();
   ?>

Ejecuta en localhost/curso_php8/ y juega con los valores.

Consejos para no enredarte

• Solo públicos: Los métodos en interfaces siempre son public; no intentes usar private o protected.
• Cumple el contrato: Si implementas una interfaz, define todos sus métodos o PHP dará error.
• Interfaces vs. clases abstractas: Usa interfaces para contratos puros; clases abstractas si necesitas código compartido.

¡A por más POO!

¡Gran trabajo, máquina! Ahora las interfaces son tu herramienta para crear código flexible y bien organizado. En la próxima lección, veremos namespaces para mantener tus clases en orden como biblioteca. Si algo no te queda claro, déjame un comentario.

Lo que aprendiste hoy, estrella:

• Qué son: Contratos que definen métodos sin implementarlos.
• implements: Vincula clases a interfaces para cumplir el contrato.
• Ejemplos vivos: Hiciste vehículos y dispositivos como crack.
• Practicaste: Creaste reproductores de audio y video como pro.
• Tip del pro: Usa interfaces para garantizar que clases distintas hablen el mismo idioma.