Come funzionano le classi e gli oggetti in PHP?

Question

Accepted Answer

PHP ha un completo supporto per la **programmazione orientata agli oggetti**: le classi definiscono struttura e comportamento, gli oggetti sono istanze. L'OOP moderno in PHP è pulito e ricco di funzionalità, con modificatori di visibilità, costruttori e comodità come la promozione delle proprietà del costruttore.

## Perché è importante

La programmazione orientata agli oggetti è centrale nel PHP moderno — i framework (Laravel, Symfony) e le basi di codice professionali sono costruiti intorno alle classi, quindi comprendere l'OOP di PHP è fondamentale per qualsiasi sviluppo PHP serio.

Sapere come definire classi con proprietà tipizzate, costruttori e metodi, i **modificatori di visibilità** (`public`/`private`/`protected`) che applicano l'incapsulamento, la sintassi `$this`/`->`/`::` e i membri statici/costanti è conoscenza essenziale quotidiana.

Le comodità moderne sono particolarmente degne di nota — la **promozione delle proprietà del costruttore** (PHP 8) riduce drasticamente il boilerplate ed è ampiamente utilizzata nel codice attuale, e le **proprietà tipizzate** rendono le classi più robuste.

L'OOP moderno in PHP è pulito e capace (un grande passo avanti rispetto alla reputazione procedurale dei primi tempi di PHP), e poiché tutti i framework e le applicazioni PHP moderni sono orientati agli oggetti, padroneggiare classi e oggetti — inclusa la sintassi specifica di PHP e le funzionalità moderne — è materiale fondamentale e imprescindibile per scrivere PHP professionale.

## Definire una 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
```

Le classi hanno **proprietà tipizzate**, un metodo `__construct` e metodi. `$this` si riferisce all'oggetto corrente, e `->` accede a proprietà/metodi (PHP usa `->`, non `.`).

## Modificatori di visibilità (incapsulamento)

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

## Promozione delle proprietà del costruttore (PHP 8 — meno 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 **promozione delle proprietà del costruttore** di PHP 8 elimina il noioso boilerplate di dichiarazione e assegnazione — una grande comodità moderna.

## Membri statici e costanti

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

I membri statici (sintassi `::`) appartengono alla classe stessa; le costanti utilizzano `const`.