Bienvenido a una nueva lección de nuestro curso básico de PHP 8. Hoy nos metemos con el encapsulamiento, un pilar clave de la programación orientada a objetos (POO) que te ayuda a mantener tus datos seguros y tu código limpio. Si ya manejas clases y polimorfismo, esto es el toque final para brillar. Todo va a ser claro, práctico y con ejemplos que te van a flipar. ¡Empecemos!

¿Qué es el encapsulamiento?

El encapsulamiento es como poner un candado en tus objetos: escondes los detalles internos (como las propiedades sensibles) y solo dejas ver lo que otros necesitan usar (a través de métodos). Esto protege tu código de cambios no deseados y hace que sea más fácil de entender y mantener.

En PHP, controlas el encapsulamiento con tres niveles de acceso:

• public: Cualquiera puede tocarlo, desde dentro o fuera de la clase.
• protected: Solo la clase y sus hijas (herencia) pueden acceder.
• private: Solo la clase misma puede usarlo; ni las hijas lo ven.

La receta básica es esta:

class MiClase {
    public $publico;
    protected $protegido;
    private $privado;

    public function metodoPublico() { /* Código */ }
    protected function metodoProtegido() { /* Código */ }
    private function metodoPrivado() { /* Código */ }
}

Probando encapsulamiento en acción

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

Ejemplo 1: Clase con diferentes accesos

<?php
    class MiClase {
        public $valor1 = "Público";
        protected $valor2 = "Protegido";
        private $valor3 = "Privado";

        public function imprimirValorPublico() {
            echo "Valor público: $this->valor1<br>";
        }

        public function imprimirValorProtegido() {
            echo "Valor protegido: $this->valor2<br>";
        }

        public function imprimirValorPrivado() {
            echo "Valor privado: $this->valor3<br>";
        }
    }

    class MiClase2 extends MiClase {
        public function imprimirValorProtegido2() {
            echo "Desde la hija: $this->valor2<br>";
        }
    }

    $valor = new MiClase();
    echo "Accediendo directamente: $valor->valor1<br>";
    // echo $valor->valor2; // ¡Error! Es protegido
    // echo $valor->valor3; // ¡Error! Es privado

    $valor->imprimirValorPublico();
    $valor->imprimirValorProtegido();
    $valor->imprimirValorPrivado();

    $valor2 = new MiClase2();
    $valor2->imprimirValorProtegido2();
?>

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

Accediendo directamente: Público
Valor público: Público
Valor protegido: Protegido
Valor privado: Privado
Desde la hija: Protegido

¿Qué pasó?

• $valor1 es public, así que lo accedimos directamente.
• $valor2 es protected, solo lo vimos a través de un método o en la clase hija.
• $valor3 es private, solo lo tocamos con un método de MiClase.
• La clase hija MiClase2 accedió a $valor2 porque es protected.

Ejemplo práctico

Ejemplo: Clase Estudiante

<?php
    class Estudiante {
        private $nombre;
        private $nota;

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

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

        public function getNota() {
            return $this->nota;
        }

        public function setNota($nota) {
            if ($nota >= 0 && $nota <= 100) {
                $this->nota = $nota;
            } else {
                echo "Nota inválida<br>";
            }
        }
    }

    $estudiante = new Estudiante("Ana", 85);
    echo "Nombre: " . $estudiante->getNombre() . "<br>";
    echo "Nota: " . $estudiante->getNota() . "<br>";
    $estudiante->setNota(95);
    echo "Nueva nota: " . $estudiante->getNota() . "<br>";
    $estudiante->setNota(150); // ¡Error!
?>

Resultado:

Nombre: Ana
Nota: 85
Nueva nota: 95
Nota inválida

¿Qué pasó?

• $nombre y $nota son private, así que nadie los toca directamente.
• Usamos métodos public (get y set) para acceder y validar datos.

Ejercicio para practicar

¡Tu turno de rockearlo! Ve a curso_php8 y prueba este reto:

1. Clase CuentaBancaria
   Crea cuenta_bancaria.php:

<?php
       class CuentaBancaria {
           private $saldo;
           private $titular;

           public function __construct($titular, $saldoInicial) {
               $this->titular = $titular;
               $this->saldo = $saldoInicial;
           }

           public function getSaldo() {
               return $this->saldo;
           }

           public function getTitular() {
               return $this->titular;
           }

           public function depositar($monto) {
               if ($monto > 0) {
                   $this->saldo += $monto;
                   echo "Depositado: $monto. Nuevo saldo: $this->saldo<br>";
               } else {
                   echo "Monto inválido<br>";
               }
           }

           public function retirar($monto) {
               if ($monto > 0 && $monto <= $this->saldo) {
                   $this->saldo -= $monto;
                   echo "Retirado: $monto. Nuevo saldo: $this->saldo<br>";
               } else {
                   echo "Retiro inválido<br>";
               }
           }
       }

       $cuenta = new CuentaBancaria("Juan Pérez", 1000);
       echo "Titular: " . $cuenta->getTitular() . "<br>";
       echo "Saldo inicial: " . $cuenta->getSaldo() . "<br>";
       $cuenta->depositar(500);
       $cuenta->retirar(200);
       $cuenta->retirar(2000); // ¡Error!
   ?>

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

Consejos para no enredarte

• Usa private por defecto: Solo haz public lo que otros realmente necesitan.
• Getters y setters: Métodos como getNombre() o setNota() son tus aliados para controlar el acceso.
• Valida siempre: En métodos como set o depositar, revisa que los datos sean correctos.

¡A por más POO!

¡Gran trabajo, máquina! Ahora el encapsulamiento es tu escudo para proteger datos y escribir código robusto. En la próxima lección, veremos clases abstractas para definir contratos claros en tus programas. Si algo no te queda claro, déjame un comentario.

Lo que aprendiste hoy:

• Qué es: Esconder detalles internos y mostrar solo lo necesario.
• public, protected, private: Tus herramientas para controlar el acceso.
• Ejemplos vivos: Jugaste con clases y herencia para ver quién toca qué.
• Practicaste: Creaste una cuenta bancaria blindada como pro.
• Tip del pro: Usa private y métodos get/set para mantener todo bajo control.