Clases y objetos en PHP: propiedades, métodos y constructor

Hola, ¿cómo están? Continuando con el curso de PHP, hoy llevamos a la práctica lo que vimos en la lección de POO: vamos a crear nuestras primeras clases y objetos.

¡Empecemos!

Crear una clase

Una clase se declara con la palabra class. Por convención, el nombre va en PascalCase: primera letra de cada palabra en mayúscula.

<?php
class Mascota
{
    public string $nombre;
    public string $tipo;
    public int $edad;
}

Eso es todo: una clase con tres propiedades. Todavía no existe ninguna mascota, solo el molde.

Crear un objeto

Para fabricar un objeto a partir de la clase usamos new:

<?php
$nupi = new Mascota();

$nupi->nombre = "Nupi";
$nupi->tipo = "Perro";
$nupi->edad = 3;

echo $nupi->nombre;   // Nupi

La flecha -> accede a lo que hay dentro del objeto. Cada objeto tiene sus propios valores:

<?php
$michi = new Mascota();
$michi->nombre = "Michi";
$michi->tipo = "Gato";

echo $nupi->nombre;    // Nupi
echo $michi->nombre;   // Michi

Una clase, dos objetos independientes.

Métodos

Los métodos son las funciones de la clase: definen lo que el objeto sabe hacer.

<?php
class Mascota
{
    public string $nombre;
    public string $tipo;
    public int $edad;

    public function describir(): string
    {
        return "{$this->nombre} es un {$this->tipo} de {$this->edad} años";
    }

    public function cumplirAnios(): void
    {
        $this->edad++;
    }
}

$nupi = new Mascota();
$nupi->nombre = "Nupi";
$nupi->tipo = "Perro";
$nupi->edad = 3;

echo $nupi->describir();   // Nupi es un Perro de 3 años
$nupi->cumplirAnios();
echo $nupi->edad;          // 4

Qué es $this

$this es la referencia al objeto concreto sobre el que se está ejecutando el método.

Cuando llamas $nupi->describir(), dentro del método $this es $nupi. Si llamas $michi->describir(), $this es $michi. El mismo código, distinto objeto.

Sin $this, el método no podría acceder a las propiedades:

<?php
public function describir(): string
{
    return $nombre;        // Error: esa variable no existe aquí
    return $this->nombre;  // Correcto
}

Fíjate además en que después de $this-> no se escribe el signo $. Es $this->nombre, nunca $this->$nombre.

El constructor

Asignar las propiedades una por una después de crear el objeto es tedioso y arriesgado: puedes olvidarte de una y quedarte con un objeto a medio construir.

El constructor es un método especial que se ejecuta automáticamente al crear el objeto:

<?php
class Mascota
{
    public string $nombre;
    public string $tipo;
    public int $edad;

    public function __construct(string $nombre, string $tipo, int $edad)
    {
        $this->nombre = $nombre;
        $this->tipo = $tipo;
        $this->edad = $edad;
    }

    public function describir(): string
    {
        return "{$this->nombre} es un {$this->tipo} de {$this->edad} años";
    }
}

$nupi = new Mascota("Nupi", "Perro", 3);
echo $nupi->describir();

Mucho mejor: en una sola línea el objeto queda completo y válido. Se llama __construct con dos guiones bajos, y es uno de los métodos mágicos de PHP.

Valores por defecto en el constructor

Funcionan igual que en cualquier función:

<?php
public function __construct(
    string $nombre,
    string $tipo,
    int $edad = 0
) { /* ... */ }

$cachorro = new Mascota("Toby", "Perro");

Promoción de propiedades

PHP 8 introdujo una forma abreviada que elimina la repetición del constructor:

<?php
class Mascota
{
    public function __construct(
        public string $nombre,
        public string $tipo,
        public int $edad = 0,
    ) {}

    public function describir(): string
    {
        return "{$this->nombre} es un {$this->tipo} de {$this->edad} años";
    }
}

Al poner el modificador de acceso delante del parámetro, PHP crea la propiedad y la asigna automáticamente. Compáralo con la versión anterior: desaparecieron seis líneas y el resultado es idéntico.

Úsala siempre que puedas. Es una de las mejoras de PHP 8 que más se agradecen en el día a día.

Propiedades de solo lectura

Si un dato no debe cambiar después de crear el objeto, márcalo como readonly:

<?php
class Mascota
{
    public function __construct(
        public readonly string $codigo,
        public string $nombre,
    ) {}
}

$nupi = new Mascota("MSC-001", "Nupi");
$nupi->nombre = "Nupita";     // permitido
$nupi->codigo = "MSC-002";    // Error: no se puede modificar

Es perfecto para identificadores, fechas de creación y cualquier dato que deba quedar fijo.

Valores por defecto en propiedades

Una propiedad puede tener valor inicial sin pasar por el constructor:

<?php
class Mascota
{
    public bool $adoptada = false;
    public array $vacunas = [];
}

Un ejemplo más completo

<?php
declare(strict_types=1);

class CuentaBancaria
{
    private float $saldo = 0;

    public function __construct(
        public readonly string $titular,
    ) {}

    public function depositar(float $monto): void
    {
        if ($monto <= 0) {
            throw new InvalidArgumentException("El monto debe ser positivo");
        }

        $this->saldo += $monto;
    }

    public function retirar(float $monto): bool
    {
        if ($monto > $this->saldo) {
            return false;
        }

        $this->saldo -= $monto;
        return true;
    }

    public function consultarSaldo(): float
    {
        return $this->saldo;
    }
}

$cuenta = new CuentaBancaria("Víctor Peña");
$cuenta->depositar(1000);
$cuenta->retirar(250);

echo $cuenta->consultarSaldo();   // 750

Fíjate en el detalle importante: $saldo es privado. No se puede hacer $cuenta->saldo = 999999. La única forma de modificarlo es a través de métodos que validan. Eso es el encapsulamiento, y lo veremos en detalle más adelante.

El destructor

Existe también __destruct(), que se ejecuta cuando el objeto deja de usarse:

<?php
public function __destruct()
{
    // cerrar una conexión, liberar un archivo...
}

Se usa poco, porque PHP libera la memoria automáticamente al terminar el script. Aparece sobre todo al manejar recursos externos.

Comprobar el tipo de un objeto

<?php
var_dump($nupi instanceof Mascota);   // true
echo get_class($nupi);                // Mascota

instanceof te va a ser muy útil cuando lleguemos a herencia y polimorfismo.

Errores comunes

• Escribir $this->$nombre con el signo de más. Es $this->nombre.
• Olvidar $this dentro de un método y usar la propiedad como si fuera una variable suelta.
• Olvidar new al crear el objeto.
• Nombrar la clase en plural. Una clase representa una cosa: Mascota, no Mascotas.

Para cerrar

Ya sabes crear clases, instanciar objetos y darles comportamiento. Las claves de esta lección: el constructor deja el objeto completo desde el primer momento, $this apunta al objeto actual, y la promoción de propiedades de PHP 8 te ahorra la mitad del código.

En la siguiente lección veremos la herencia, que es cómo se reutiliza una clase en otra.

Saludos y éxitos.