¿Cómo funcionan las clases y los objetos en PHP?

Question

Accepted Answer

PHP tiene soporte completo para **programación orientada a objetos**: las clases definen la estructura y el comportamiento, los objetos son instancias. La POO moderna de PHP es limpia y rica en características, con modificadores de visibilidad, constructores y comodidades como la promoción de propiedades del constructor.

## Definiendo una clase

```php
<?php
class User {
    public string $name;            // typed property
    private int $age;                // visibility: public / private / protected

public function __construct(string $name, int $age) {   // constructor
        $this->name = $name;          // $this refers to the instance; -> accesses members
        $this->age = $age;
    }

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

$user = new User("Ann", 30);     // create an instance
echo $user->name;                 // access a property
echo $user->greet();              // call a method
```

Las clases tienen **propiedades tipadas**, un método `__construct` y métodos. `$this` se refiere al objeto actual, y `->` accede a propiedades/métodos (PHP usa `->`, no `.`).

## Modificadores de visibilidad (encapsulación)

```php
public    // accessible everywhere
private   // only within THIS class
protected // this class and subclasses
```

## Promoción de propiedades del constructor (PHP 8 — menos boilerplate)

```php
class User {
    // declare AND assign properties directly in the constructor signature
    public function __construct(
        public string $name,
        private int $age = 0,
    ) {}
    // equivalent to declaring the properties + assigning them — much less code
}
```

La **promoción de propiedades del constructor** de PHP 8 elimina el código repetitivo de declarar-y-asignar — una comodidad moderna importante.

## Miembros estáticos y constantes

```php
class Counter {
    public static int $count = 0;      // belongs to the CLASS, not instances
    const MAX = 100;                    // class constant

public static function increment(): void {
        self::$count++;                  // access static via self::
    }
}
Counter::increment();                    // call via ClassName::
Counter::MAX;
```

Los miembros estáticos (sintaxis `::`) pertenecen a la clase en sí; las constantes usan `const`.

## Por qué es importante

La programación orientada a objetos es central en el PHP moderno — los frameworks (Laravel, Symfony) y las bases de código profesionales se construyen alrededor de las clases, por lo que comprender la POO de PHP es fundamental para cualquier desarrollo PHP serio.

Saber cómo definir clases con propiedades tipadas, constructores y métodos, los **modificadores de visibilidad** (`public`/`private`/`protected`) que hacen cumplir la encapsulación, la sintaxis `$this`/`->`/`::` y los miembros estáticos/constantes es conocimiento esencial cotidiano.

Las comodidades modernas son particularmente dignas de conocimiento — la **promoción de propiedades del constructor** (PHP 8) reduce dramáticamente el boilerplate y se usa ampliamente en el código actual, y las **propiedades tipadas** hacen que las clases sean más robustas.

La POO moderna de PHP es limpia y capaz (muy diferente de la antigua reputación procedural de PHP), y como todos los frameworks y aplicaciones modernas de PHP son orientados a objetos, dominar las clases y los objetos — incluida la sintaxis específica de PHP y las características modernas — es material fundamental y necesario para escribir PHP profesional.