Bienvenido a una nueva lección de nuestro curso básico de PHP 8. Hoy nos metemos con las clases abstractas, una herramienta clave de la programación orientada a objetos (POO) que te ayuda a definir cómo deben comportarse otras clases sin ensuciarte las manos. Si ya manejas encapsulamiento y polimorfismo, esto te va a encantar. Todo va a ser claro, práctico y con ejemplos que te van a flipar. ¡Empecemos!

¿Qué son las clases abstractas?

Una clase abstracta es como un plano a medio terminar: establece reglas y estructuras, pero no puedes usarla directamente para crear objetos. Es una plantilla para otras clases (sus «hijas») que heredan de ella. Piensa en una clase abstracta como un entrenador que dice: «Tienes que hacer esto, pero tú decides cómo». Sirve para compartir código común y obligar a las clases hijas a implementar ciertos métodos.

Características clave:

• No se instancian: No puedes hacer new ClaseAbstracta().
• Métodos abstractos: Declaras métodos sin código; las hijas deben implementarlos.
• Métodos normales: También puedes incluir métodos con código que las hijas heredan.

La receta básica en PHP es esta:

abstract class ClaseAbstracta {
    public $atributo;

    public function metodoNormal() {
        // Código listo para usar
    }

    abstract public function metodoAbstracto(); // Sin código, solo la firma
}

• abstract: Indica que la clase o método es abstracto.
• Las clases hijas usan extends y deben implementar todos los métodos abstractos.

Probando clases abstractas en acción

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

Ejemplo 1: Clase abstracta básica

<?php
    abstract class MiClaseAbstracta {
        abstract protected function obtenerValor();
        abstract public function asignarValor($valor);

        public function imprimirValor() {
            echo $this->obtenerValor() . "<br>";
        }
    }

    class MiClase extends MiClaseAbstracta {
        protected function obtenerValor() {
            return "Mensaje desde MiClase";
        }

        public function asignarValor($valor) {
            return "El valor es: $valor";
        }
    }

    $clase = new MiClase();
    $clase->imprimirValor();
    echo $clase->asignarValor(100) . "<br>";
?>

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

Mensaje desde MiClase
El valor es: 100

¿Qué pasó?

• MiClaseAbstracta define dos métodos abstractos (obtenerValor y asignarValor) y uno normal (imprimirValor).
• MiClase hereda y da vida a los métodos abstractos.
• No podemos hacer new MiClaseAbstracta(); solo usamos MiClase.

Ejemplo práctico

Ejemplo: Vehículo abstracto

<?php
    abstract class Vehiculo {
        protected $marca;

        public function __construct($marca) {
            $this->marca = $marca;
        }

        abstract public function mover();

        public function describir() {
            echo "Este es un vehículo de marca $this->marca.<br>";
        }
    }

    class Coche extends Vehiculo {
        public function mover() {
            echo "El coche $this->marca avanza por la carretera.<br>";
        }
    }

    class Moto extends Vehiculo {
        public function mover() {
            echo "La moto $this->marca acelera por la pista.<br>";
        }
    }

    $coche = new Coche("Toyota");
    $moto = new Moto("Yamaha");

    $coche->describir();
    $coche->mover();
    $moto->describir();
    $moto->mover();
?>

Resultado:

Este es un vehículo de marca Toyota.
El coche Toyota avanza por la carretera.
Este es un vehículo de marca Yamaha.
La moto Yamaha acelera por la pista.

¿Qué pasó?

• Vehiculo es abstracta y obliga a sus hijas a implementar mover().
• Coche y Moto heredan, usan el método normal describir() y definen mover() a su manera.

Ejercicio para practicar

¡Tu turno para pica codigo! Ve a curso_php8 y prueba este reto:

1. Clase Programador
   Crea programador_abstracto.php:

 <?php
       abstract class Programador {
           protected $nombre;
           protected $ingresos;

           public function __construct($nombre, $ingresos) {
               $this->nombre = $nombre;
               $this->ingresos = $ingresos;
           }

           abstract public function calcularIngresos();

           public function getNombre() {
               return $this->nombre;
           }
       }

       class Freelance extends Programador {
           public function calcularIngresos() {
               return "El freelance $this->nombre gana $this->ingresos por proyecto.";
           }
       }

       class Empleado extends Programador {
           public function calcularIngresos() {
               return "El empleado $this->nombre gana $this->ingresos mensual.";
           }
       }

       class Emprendedor extends Programador {
           public function calcularIngresos() {
               return "El emprendedor $this->nombre tiene ingresos variables de $this->ingresos.";
           }
       }

       $freelance = new Freelance("Ana", 2000);
       $empleado = new Empleado("Luis", 3000);
       $emprendedor = new Emprendedor("Sofía", 5000);

       echo $freelance->calcularIngresos() . "<br>";
       echo $empleado->calcularIngresos() . "<br>";
       echo $emprendedor->calcularIngresos() . "<br>";
   ?>

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

Consejos para no enredarte

• No instancies: Si intentas new ClaseAbstracta(), PHP se quejará.
• Métodos abstractos obligatorios: Las hijas deben implementarlos todos, o dará error.
• Mezcla con cuidado: Usa métodos normales para compartir código, pero mantén los abstractos para forzar reglas.

¡A por más POO!

¡Gran trabajo, máquina! Ahora las clases abstractas son tu guía para crear código organizado y flexible. En la próxima lección, veremos interfaces para definir contratos aún más claros. Si algo no te queda claro, déjame un comentario.

Lo que aprendiste hoy:

• Qué son: Plantillas que no se instancian, pero guían a las clases hijas.
• abstract: La palabra que las define, para clases y métodos.
• Ejemplos vivos: Hiciste clases y vehículos abstractos como crack.
• Practicaste: Creaste programadores con ingresos como pro.
• Tip del pro: Usa clases abstractas para compartir código y forzar reglas al mismo tiempo.