Capire la Programmazione Orientata agli Oggetti in PHP

La Programmazione Orientata agli Oggetti (OOP) è un modo di strutturare il codice attorno agli oggetti — unità autonome che raggruppano dati (chiamati proprietà) e il comportamento che opera su quei dati (chiamati metodi). Invece di scrivere un lungo elenco di funzioni che si passano dati, si modellano le entità del proprio dominio (un utente, un ordine, una connessione al database) come oggetti e si lascia che gestiscano il proprio stato.

PHP supporta l'OOP fin da PHP 5, e i moderni framework PHP come Laravel e Symfony sono costruiti quasi interamente su di esso. Questo capitolo spiega cos'è l'OOP, perché esiste e come i concetti fondamentali si traducono nella sintassi PHP. Alla fine saprai la differenza tra una classe e un oggetto e riconoscerai i quattro pilastri dell'OOP: incapsulamento, ereditarietà, polimorfismo e astrazione.

PHP procedurale vs. orientato agli oggetti

Prima delle classi, il codice PHP era tipicamente procedurale — una sequenza di istruzioni e funzioni che operavano su variabili semplici:

$carMake = "Ford";
$carModel = "Mustang";

function describeCar($make, $model) {
  return "The car is a $make $model.";
}

echo describeCar($carMake, $carModel);
// The car is a Ford Mustang.

Questo funziona, ma i dati ($carMake, $carModel) e la funzione che li utilizza sono collegati in modo lasco. Man mano che un progetto cresce, diventa difficile tenere traccia di quali funzioni appartengono a quali dati. L'OOP risolve questo problema raggruppando i dati e il comportamento in un'unica classe.

Classi e oggetti

I due concetti fondamentali nell'OOP sono la classe e l'oggetto:

• Una classe è un modello. Descrive quali proprietà e metodi avrà un oggetto, ma non è un valore che puoi usare direttamente — come un progetto architettonico per una casa.
• Un oggetto è un'istanza concreta creata da quel modello, con valori reali inseriti — come una casa effettivamente costruita dal progetto.

In PHP si dichiara una classe con la parola chiave class e si crea un oggetto da essa con l'operatore new:

class Car {
  public $make;
  public $model;
}

$car = new Car();   // $car is an object (an instance of Car)
$car->make = "Ford";
$car->model = "Mustang";

echo $car->make;    // Ford

È possibile creare quanti oggetti indipendenti si vuole da una classe, e ciascuno mantiene la propria copia delle proprietà. L'operatore freccia -> accede a una proprietà o a un metodo su un oggetto. Per saperne di più consulta PHP Classes and Objects.

I quattro pilastri dell'OOP

L'OOP è costruita su quattro principi fondamentali. PHP offre una funzionalità del linguaggio dedicata per ciascuno.

Incapsulamento

L'incapsulamento significa tenere insieme i dati di un oggetto e i metodi che li modificano, controllando l'accesso dall'esterno. Contrassegnando le proprietà come private e esponendole solo tramite metodi, si protegge un oggetto dall'essere messo in uno stato non valido.

class BankAccount {
  private $balance = 0;

  public function deposit($amount) {
    if ($amount > 0) {
      $this->balance += $amount;
    }
  }

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

$account = new BankAccount();
$account->deposit(100);
echo $account->getBalance();   // 100

Qui $balance non può essere impostato direttamente su un valore privo di senso — ogni modifica passa attraverso deposit(), che valida l'input.

Ereditarietà

L'ereditarietà consente a una classe di riutilizzare le proprietà e i metodi di un'altra. Una classe figlia dichiarata con extends acquisisce automaticamente tutto dalla classe padre e può aggiungervi o sovrascriverlo. Questo evita di duplicare il codice condiviso. Vedi PHP Inheritance per i dettagli.

class Vehicle {
  public function start() {
    return "Engine started.";
  }
}

class Car extends Vehicle {
  public function openTrunk() {
    return "Trunk opened.";
  }
}

$car = new Car();
echo $car->start();        // Engine started.  (inherited)
echo $car->openTrunk();    // Trunk opened.     (its own)

Polimorfismo

Il polimorfismo ("molte forme") significa che classi diverse possono rispondere alla stessa chiamata di metodo in modo diverso. Il codice che chiama makeSound() non ha bisogno di sapere se sta lavorando con un Dog o un Cat:

class Dog {
  public function makeSound() { return "Woof"; }
}

class Cat {
  public function makeSound() { return "Meow"; }
}

foreach ([new Dog(), new Cat()] as $animal) {
  echo $animal->makeSound() . "\n";
}
// Woof
// Meow

Questo è molto potente quando combinato con le interfaces, che garantiscono che ogni classe fornisca lo stesso insieme di metodi.

Astrazione

L'astrazione significa nascondere i dettagli di implementazione dietro un'interfaccia semplice e ben definita. Gli utenti di una classe lavorano con cosa essa fa, non come lo fa. PHP supporta questo tramite le abstract classes e le interfacce, che definiscono le firme dei metodi senza (o con implementazione parziale).

Tutto insieme: un esempio completo

La classe qui sotto combina proprietà, un constructor che viene eseguito automaticamente quando l'oggetto viene creato, e un metodo:

class Car {
  public $color;
  public $make;
  public $model;

  function __construct($color, $make, $model) {
    $this->color = $color;
    $this->make  = $make;
    $this->model = $model;
  }

  function getDescription() {
    return "The car is a " . $this->make . " " . $this->model . " in " . $this->color . " color.";
  }
}

$car = new Car("red", "Ford", "Mustang");
echo $car->getDescription();
// The car is a Ford Mustang in red color.

Cosa succede qui:

• La classe Car dichiara tre proprietà pubbliche — color, make e model.
• __construct() è un metodo speciale che PHP chiama nel momento in cui viene eseguito new Car(...). Copia gli argomenti nelle proprietà dell'oggetto usando $this, che si riferisce sempre all'oggetto corrente.
• getDescription() legge quelle proprietà e restituisce una frase.
• new Car("red", "Ford", "Mustang") costruisce l'oggetto; chiamando $car->getDescription() si ottiene l'output mostrato nel commento.

Quando usare l'OOP?

L'OOP eccelle quando un'applicazione ha molti concetti correlati con i propri dati e comportamenti, quando si vuole riutilizzare il codice in un progetto, o quando si lavora con un framework che lo richiede. Per un piccolo script usa-e-getta, le semplici funzioni procedurali possono essere più semplici. La maggior parte del PHP reale — API, applicazioni web, librerie — si basa sull'OOP perché mantiene i codebase in crescita organizzati e testabili.

Conclusione

La programmazione orientata agli oggetti organizza il codice attorno a oggetti che raggruppano dati e comportamenti. Si definisce una classe come modello e si creano oggetti da essa con new. I quattro pilastri — incapsulamento, ereditarietà, polimorfismo e astrazione — forniscono strumenti per proteggere i dati, riutilizzare il codice e mantenere le applicazioni di grandi dimensioni gestibili.

Per approfondire, continua con PHP Classes and Objects, poi esplora inheritance, interfaces, abstract classes e traits.

Esercitazione