Conceptos esenciales de POO en PHP

1. Clase

Clase: Es una plantilla o molde que define los atributos (características o variables) y métodos (comportamientos o funciones) comunes para un tipo de dato. Permite agrupar tareas y crear «tipos» personalizados.

class Producto {
    // Atributos
    public $nombre;
    public $precio;
    // Método (constructor)
    public function __construct($nombre, $precio) {
        $this->nombre = $nombre;
        $this->precio = $precio;
    }
}

2. Objeto

Objeto: Es una instancia concreta e independiente de una clase. Aunque comparte la estructura de la clase, tiene sus propios valores y datos específicos.

// Instanciar: crear un objeto a partir de la clase

$camiseta = new Producto("Camiseta", 19.99); // $camiseta es el objeto que tiene sus propios datos.

3. Interfaz

Interfaz: Es un contrato que obliga a las clases a cumplir con ciertos estándares. Define métodos vacíos (sin implementación) que las clases que implementen la interfaz deben incluir obligatoriamente. Todos sus métodos son públicos.

interface Vehiculo {
    public function getTipo(); // Método vacío (contrato)
    public function getRuedas();
}

// La clase Coche está OBLIGADA a definir getTipo y getRuedas
class Coche implements Vehiculo {
    public function getTipo() {
        return "Coche";
    }
    public function getRuedas() {
        return 4;
    }
}

4. Clase abstracta

Definición: Es una clase que no puede instanciarse directamente (no puedes hacer new ClaseAbstracta) y sirve como base para otras clases. Funciona como una mezcla: puede tener métodos con código (como una clase normal) y métodos abstractos (sin código) que obligan a las clases hijas a implementarlos.

abstract class Animal {
    // Método abstracto: obliga a la hija a definirlo
    abstract public function sonido();
}

class Perro extends Animal {
    // Implementación obligatoria
    public function sonido() {
        echo "Guau";
    }
}

5. Método estático

Definición: Son métodos que pertenecen a la clase en su conjunto y no a una instancia (objeto) individual. Se pueden llamar sin necesidad de crear un objeto con new.

class Hija {
    public static function mostrarMensaje() {
        echo "Hola desde un método estático";
    }
}

// Se llama directamente usando la clase
Hija::mostrarMensaje();

6. Constantes

Definición: Son valores fijos definidos dentro de una clase que no cambian durante la ejecución del programa. Se definen con const, no llevan el signo $ y, por convención, van en mayúsculas.

Ejemplo:

class Configuracion {
    const VERSION = "1.0.0";
}

// Acceso sin instanciar la clase
echo Configuracion::VERSION;

7. Operador de resolución de alcance (::)

Definición: Es el operador utilizado para acceder a los elementos estáticos y constantes de una clase (elementos que pertenecen a la clase y no al objeto). Se usa también con parent:: para acceder al padre y self:: para la propia clase.

class Mensajes {
    const TEXTO = "Hola";
    public function mostrar() {
        echo self::TEXTO; // Acceso interno
    }
}

echo Mensajes::TEXTO; // Acceso externo con ::

8. Autocarga (autoload)

Definición: Es un mecanismo que permite cargar las clases automáticamente desde diferentes directorios cuando el código las necesita, evitando tener que escribir muchos require o include manualmente.

function carga($class) {
    // Busca el archivo con el nombre de la clase en la carpeta 'classes'
    require_once '../classes/' . $class . '.php';
}

// Registra la función para que PHP la use automáticamente
spl_autoload_register('carga');

9. Herencia

Definición: Mecanismo que permite que una clase nueva (hija) obtenga propiedades y métodos de una clase existente (padre) usando la palabra clave extends. Permite reutilizar código y crear jerarquías. PHP solo permite heredar de una sola clase.

class Producto { ... } // Padre

// Hija hereda todo lo público y protegido de Producto
class Camiseta extends Producto {
    public $talla; // Atributo extra propio
    public function __construct($nombre, $precio, $talla) {
        parent::__construct($nombre, $precio); // Reutiliza constructor padre
        $this->talla = $talla;
    }
}

10. Encapsulamiento

Definición: Es un principio de la POO que consiste en ocultar los datos internos de una clase y controlar el acceso a ellos mediante métodos (modificadores de acceso). Los modificadores principales son:

  • Public: Accesible desde cualquier sitio.
  • Private: Accesible solo dentro de la clase que lo define (ni siquiera las hijas).
  • Protected: Accesible desde la clase y sus hijas (herencia).

Ejemplo:

class Ejemplo {
    private $secreto = "1234"; // Accesible aquí dentro
    public $info = "Público";  // Accesible desde fuera

    public function mostrarSecreto() {
        return $this->secreto; // Acceso controlado mediante un método público
    }
}