Como as classes e objetos funcionam em PHP?

Question

Accepted Answer

PHP tem suporte completo a **programação orientada a objetos**: classes definem estrutura e comportamento, objetos são instâncias. O PHP OOP moderno é limpo e rico em recursos, com modificadores de visibilidade, construtores e conveniências como promoção de propriedade do construtor.

## Definindo uma classe

```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
```

As classes têm **propriedades tipadas**, um método `__construct` e métodos. `$this` refere-se ao objeto atual, e `->` acessa propriedades/métodos (PHP usa `->`, não `.`).

## Modificadores de visibilidade (encapsulamento)

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

## Promoção de propriedade do construtor (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
}
```

A **promoção de propriedade do construtor** do PHP 8 elimina o repetitivo boilerplate declare-then-assign — uma grande conveniência moderna.

## Membros estáticos e 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;
```

Os membros estáticos (sintaxe `::`) pertencem à própria classe; constantes usam `const`.

## Por que isso importa

A programação orientada a objetos é central para o PHP moderno — frameworks (Laravel, Symfony) e bases de código profissionais são construídos em torno de classes, então entender PHP OOP é fundamental para qualquer desenvolvimento PHP sério.

Saber como definir classes com propriedades tipadas, construtores e métodos, os **modificadores de visibilidade** (`public`/`private`/`protected`) que reforçam encapsulamento, a sintaxe `$this`/`->`/`::` e membros/constantes estáticos é conhecimento essencial do dia a dia.

As conveniências modernas são particularmente dignas de nota — a **promoção de propriedade do construtor** (PHP 8) reduz dramaticamente o boilerplate e é amplamente usada em código atual, e **propriedades tipadas** tornam as classes mais robustas.

O PHP OOP moderno é limpo e capaz (muito diferente da reputação procedural inicial do PHP), e como todos os frameworks e aplicações PHP modernos são orientados a objetos, dominar classes e objetos — incluindo a sintaxe específica do PHP e recursos modernos — é material fundamental e imprescindível para escrever PHP profissional.