Entendiendo la Programación Orientada a Objetos en PHP

La Programación Orientada a Objetos (OOP) es una forma de estructurar el código en torno a objetos — unidades autocontenidas que agrupan datos (llamados propiedades) y el comportamiento que actúa sobre esos datos (llamados métodos). En lugar de escribir una larga lista de funciones que pasan datos de un lado a otro, se modelan las entidades del dominio del problema (un usuario, un pedido, una conexión a base de datos) como objetos y se les permite gestionar su propio estado.

PHP ha soportado OOP desde PHP 5, y los frameworks modernos de PHP como Laravel y Symfony están construidos casi por completo sobre él. Este capítulo explica qué es OOP, por qué existe y cómo las ideas principales se traducen en sintaxis PHP. Al finalizar conocerás la diferencia entre una clase y un objeto, y reconocerás los cuatro pilares de OOP: encapsulamiento, herencia, polimorfismo y abstracción.

PHP procedural vs. orientado a objetos

Antes de las clases, el código PHP era típicamente procedural — una secuencia de instrucciones y funciones que operaban sobre variables simples:

$carMake = "Ford";
$carModel = "Mustang";

function describeCar($make, $model) {
  return "The car is a $make $model.";
}

echo describeCar($carMake, $carModel);
// The car is a Ford Mustang.

Esto funciona, pero los datos ($carMake, $carModel) y la función que los usa están conectados de forma débil. A medida que un proyecto crece, resulta difícil rastrear qué funciones pertenecen a qué datos. OOP resuelve esto empaquetando los datos y el comportamiento juntos en una única clase.

Clases y objetos

Los dos conceptos fundamentales en OOP son la clase y el objeto:

• Una clase es un plano de construcción. Describe qué propiedades y métodos tendrá un objeto, pero no es un valor que puedas usar directamente — como un plano arquitectónico de una casa.
• Un objeto es una instancia concreta creada a partir de ese plano, con valores reales — como una casa real construida a partir del plano.

En PHP, se declara una clase con la palabra clave class y se crea un objeto a partir de ella con el operador new:

class Car {
  public $make;
  public $model;
}

$car = new Car();   // $car is an object (an instance of Car)
$car->make = "Ford";
$car->model = "Mustang";

echo $car->make;    // Ford

Puedes crear tantos objetos independientes a partir de una clase como necesites, y cada uno conserva su propia copia de las propiedades. El operador flecha -> accede a una propiedad o método de un objeto. Aprende más en Clases y Objetos de PHP.

Los cuatro pilares de OOP

OOP se basa en cuatro principios fundamentales. PHP te proporciona una característica del lenguaje dedicada para cada uno.

Encapsulamiento

El encapsulamiento consiste en mantener juntos los datos de un objeto y los métodos que los modifican, controlando el acceso desde el exterior. Al marcar propiedades como private y exponerlas solo a través de métodos, proteges un objeto de ser colocado en un estado inválido.

class BankAccount {
  private $balance = 0;

  public function deposit($amount) {
    if ($amount > 0) {
      $this->balance += $amount;
    }
  }

  public function getBalance() {
    return $this->balance;
  }
}

$account = new BankAccount();
$account->deposit(100);
echo $account->getBalance();   // 100

Aquí $balance no puede establecerse directamente con un valor sin sentido — todo cambio pasa por deposit(), que valida la entrada.

Herencia

La herencia permite que una clase reutilice las propiedades y métodos de otra. Una clase hija declarada con extends obtiene automáticamente todo lo de su padre y puede añadir o sobreescribir. Esto evita duplicar código compartido. Consulta Herencia en PHP para más detalles.

class Vehicle {
  public function start() {
    return "Engine started.";
  }
}

class Car extends Vehicle {
  public function openTrunk() {
    return "Trunk opened.";
  }
}

$car = new Car();
echo $car->start();        // Engine started.  (inherited)
echo $car->openTrunk();    // Trunk opened.     (its own)

Polimorfismo

El polimorfismo ("muchas formas") significa que diferentes clases pueden responder a la misma llamada de método a su propia manera. El código que llama a makeSound() no necesita saber si está manejando un Dog o un Cat:

class Dog {
  public function makeSound() { return "Woof"; }
}

class Cat {
  public function makeSound() { return "Meow"; }
}

foreach ([new Dog(), new Cat()] as $animal) {
  echo $animal->makeSound() . "\n";
}
// Woof
// Meow

Esto es más poderoso cuando se combina con interfaces, que garantizan que cada clase proporcione el mismo conjunto de métodos.

Abstracción

La abstracción significa ocultar los detalles de implementación detrás de una interfaz simple y bien definida. Los usuarios de una clase trabajan con qué hace, no con cómo lo hace. PHP lo soporta mediante clases abstractas e interfaces, que definen firmas de métodos sin implementación (o con implementación parcial).

Juntando todo: un ejemplo completo

La clase a continuación combina propiedades, un constructor que se ejecuta automáticamente cuando se crea el objeto, y un método:

class Car {
  public $color;
  public $make;
  public $model;

  function __construct($color, $make, $model) {
    $this->color = $color;
    $this->make  = $make;
    $this->model = $model;
  }

  function getDescription() {
    return "The car is a " . $this->make . " " . $this->model . " in " . $this->color . " color.";
  }
}

$car = new Car("red", "Ford", "Mustang");
echo $car->getDescription();
// The car is a Ford Mustang in red color.

Lo que ocurre aquí:

• La clase Car declara tres propiedades públicas — color, make y model.
• __construct() es un método especial que PHP llama en el momento en que se ejecuta new Car(...). Copia los argumentos en las propiedades del objeto usando $this, que siempre hace referencia al objeto actual.
• getDescription() lee esas propiedades y devuelve una oración.
• new Car("red", "Ford", "Mustang") construye el objeto; llamar a $car->getDescription() produce la salida mostrada en el comentario.

¿Cuándo deberías usar OOP?

OOP brilla cuando una aplicación tiene muchos conceptos relacionados con sus propios datos y comportamiento, cuando quieres reutilizar código en un proyecto, o cuando trabajas con un framework que lo requiere. Para un pequeño script puntual, las funciones procedurales simples pueden ser más sencillas. La mayoría del PHP del mundo real — APIs, aplicaciones web, bibliotecas — se apoya en OOP porque mantiene las bases de código en crecimiento organizadas y comprobables.

Conclusión

La programación orientada a objetos organiza el código en torno a objetos que agrupan datos con comportamiento. Defines una clase como un plano y creas objetos a partir de ella con new. Los cuatro pilares — encapsulamiento, herencia, polimorfismo y abstracción — te ofrecen herramientas para proteger datos, reutilizar código y mantener las aplicaciones grandes.

Para profundizar, continúa con Clases y Objetos de PHP, luego explora herencia, interfaces, clases abstractas y traits.

Práctica