Clases y objetos

PHP lleva mucho tiempo siendo un lenguaje totalmente orientado a objetos — el PHP moderno, y todo framework importante, se apoya fuertemente en las clases.

Definiendo una clase

<?php
class User {
    public string $name;
    public string $role;

    public function greet(): string {
        return "Hi, I'm {$this->name}";
    }
}

$user = new User();
$user->name = "Amara";
$user->role = "admin";

echo $user->greet();

Una clase es un plano; new User() crea una instancia (un objeto) a partir de ella. $this dentro de un método se refiere a la instancia específica sobre la que se llamó el método — $user->name y algún otro $otherUser->name son independientes, aunque ambos provengan de la misma clase.

Constructores

<?php
class User {
    public string $name;
    public string $role;

    public function __construct(string $name, string $role = "member") {
        $this->name = $name;
        $this->role = $role;
    }
}

$user = new User("Amara", "admin");

__construct() se ejecuta automáticamente cuando new crea una instancia, y es el lugar estándar para exigir y asignar el estado inicial de un objeto nuevo — esto es mucho más común en código real que establecer las propiedades una por una después de la creación, como en el primer ejemplo.

Promoción de propiedades en el constructor

<?php
class User {
    public function __construct(
        public string $name,
        public string $role = "member",
    ) {}
}

$user = new User("Amara", "admin");
echo $user->name;

Este atajo (añadido en PHP 8) declara y asigna una propiedad directamente en la lista de parámetros del constructor — public string $name aquí tanto define la propiedad $name como le asigna el valor pasado, eliminando las repetitivas líneas $this->name = $name; del ejemplo anterior.

Visibilidad: public, protected, private

<?php
class BankAccount {
    private float $balance = 0;

    public function deposit(float $amount): void {
        $this->balance += $amount;
    }

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

$account = new BankAccount();
$account->deposit(100);
echo $account->getBalance(); // 100
// $account->balance; // Error: cannot access private property

Las propiedades/métodos public son accesibles desde cualquier lugar. private restringe el acceso solo al código dentro de la misma clase — $account->balance desde fuera sería un error fatal, obligando a que todos los cambios pasen por deposit(), que puede imponer reglas (como nunca permitir un saldo negativo) que el acceso directo a la propiedad evitaría por completo. protected se sitúa en un punto intermedio: accesible dentro de la clase y de cualquier clase que la extienda, algo que se cubre en la siguiente lección.

Propiedades y métodos estáticos

<?php
class Counter {
    public static int $count = 0;

    public static function increment(): void {
        self::$count++;
    }
}

Counter::increment();
Counter::increment();
echo Counter::$count; // 2

Los miembros static pertenecen a la propia clase, no a ninguna instancia individual — se accede a ellos con :: en lugar de ->, y se comparten entre todas las instancias (o son accesibles sin ninguna instancia en absoluto, como se muestra aquí). self:: se refiere a la clase actual desde dentro de un contexto estático.