Comprendere la Programmazione Orientata agli Oggetti (OOP) in PHP

La Programmazione Orientata agli Oggetti (OOP) è un paradigma di programmazione costruito attorno al concetto di "oggetti", che raggruppano insieme dati (proprietà) e comportamento (metodi) che operano su tali dati. Invece di distribuire variabili e funzioni correlate in tutto lo script, la OOP ti consente di raggrupparle in unità autonome che modellano le entità con cui l'applicazione lavora — un User, un Order, un Product.

Questo capitolo copre i due fondamenti della OOP in PHP — classi e oggetti — per poi illustrare i tre concetti che utilizzerai ogni giorno: incapsulamento, ereditarietà e polimorfismo. Al termine sarai in grado di leggere e scrivere classi PHP con sicurezza e di sapere quale funzionalità risolve quale problema.

Cosa sono Classi e Oggetti nella OOP PHP?

Una classe è un progetto. Descrive quali dati contiene un oggetto e cosa può fare, ma non è una cosa in sé — proprio come un progetto architettonico non è una casa. Un oggetto è un'istanza concreta costruita da quel progetto, creata con la parola chiave new. Puoi creare molti oggetti da una sola classe, ciascuno con i propri dati.

Un modo utile per ricordarlo: la classe è la formina per i biscotti, gli oggetti sono i biscotti. Classi e oggetti sono i mattoni fondamentali della OOP in PHP.

Definire le Classi in PHP

Le classi in PHP si definiscono usando la parola chiave class, seguita dal nome della classe. Le proprietà e i metodi di una classe vengono definiti all'interno della sua definizione, tra parentesi graffe ({}). Ecco un esempio di definizione di classe in PHP:

Esempio di definizione di una classe in PHP

class User {
    public $username;
    public $email;
    public function __construct($username, $email) {
        $this->username = $username;
        $this->email = $email;
    }
    public function getUsername() {
        return $this->username;
    }
    public function getEmail() {
        return $this->email;
    }
}

In questo esempio, la classe User ha due proprietà, $username e $email, e due metodi, getUsername() e getEmail(). Il metodo __construct è un metodo speciale costruttore in PHP: viene eseguito automaticamente nel momento in cui un oggetto viene creato, il che lo rende il posto naturale per impostare lo stato iniziale di un oggetto. All'interno di qualsiasi metodo, $this fa riferimento all'oggetto corrente, quindi $this->username significa "la proprietà username di questo oggetto". Per saperne di più sui costruttori e sul metodo di pulizia corrispondente, consulta PHP Constructor e PHP Destructor.

Creare Oggetti dalle Classi

Per creare un oggetto da una classe, usa la parola chiave new, seguita dal nome della classe. Ecco un esempio di come creare un oggetto dalla classe User:

PHP crea un oggetto da una classe usando la parola chiave new

$user = new User("John Doe", "[email protected]");

Questo crea un nuovo oggetto User e lo memorizza nella variabile $user. Puoi accedere alle proprietà e ai metodi dell'oggetto usando l'operatore freccia (->). Ecco un esempio di come accedere alle proprietà e ai metodi dell'oggetto $user:

PHP accede alle proprietà e ai metodi dell'oggetto usando l'operatore freccia

echo $user->username; // Outputs: "John Doe"
echo $user->email; // Outputs: "[email protected]"
echo $user->getUsername(); // Outputs: "John Doe"
echo $user->getEmail(); // Outputs: "[email protected]"

Incapsulamento: Controllare l'Accesso ai Dati

Negli esempi precedenti, ogni proprietà è dichiarata public, il che significa che qualsiasi codice può leggerla o modificarla direttamente ($user->email = "..."). Questo è comodo ma rischioso — consente al resto del programma di portare un oggetto in uno stato non valido. L'incapsulamento è la pratica di nascondere gli interni di un oggetto ed esporre invece un'interfaccia controllata.

PHP fornisce tre modificatori di visibilità per proprietà e metodi:

Rendendo una proprietà private ed esponendo metodi per leggerla o modificarla, mantieni la validazione in un unico posto:

<?php

class BankAccount
{
    private $balance = 0;

    public function deposit($amount)
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException("Deposit must be positive.");
        }
        $this->balance += $amount;
    }

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

$account = new BankAccount();
$account->deposit(100);
$account->deposit(50);
echo $account->getBalance(); // Outputs: 150

Poiché $balance è private, nessun codice esterno può impostarlo direttamente a un numero negativo — ogni modifica deve passare per deposit(), dove si trova la regola. Per un'analisi più approfondita delle tre parole chiave, leggi PHP Access Modifiers.

Ereditarietà nella OOP PHP

L'ereditarietà è una funzionalità della OOP che consente alle classi di ereditare proprietà e metodi dalle classi genitore. Questo permette agli sviluppatori di creare nuove classi basate su classi esistenti, senza dover riscrivere tutto il codice da zero. In PHP, l'ereditarietà si definisce usando la parola chiave extends. Ecco un esempio di ereditarietà in PHP:

Esempio PHP di ereditarietà, una funzionalità della OOP che consente alle classi

class Admin extends User {
    public $permissions;
    public function __construct($username, $email, $permissions) {
        parent::__construct($username, $email);
        $this->permissions = $permissions;
    }
    public function getPermissions() {
       return $this->permissions;
   }
}

In questo esempio, la classe Admin estende la classe User e ne eredita proprietà e metodi. La classe Admin ha anche una propria proprietà, $permissions, e un metodo, getPermissions(). La parola chiave parent:: viene usata per chiamare il metodo __construct della classe genitore, consentendo alla classe Admin di riutilizzare la logica della classe User invece di duplicarla. Una classe può estendere solo un genitore in PHP. Per il quadro completo, consulta PHP Inheritance.

Polimorfismo nella OOP PHP

Il polimorfismo è una funzionalità della OOP che consente di trattare oggetti di classi diverse come oggetti della stessa classe. Questo permette agli sviluppatori di scrivere codice generico che può lavorare con oggetti di classi diverse, purché abbiano gli stessi metodi. In PHP, il polimorfismo si ottiene definendo metodi comuni nelle classi genitore e implementandoli nelle classi figlie. Ecco un esempio di polimorfismo in PHP:

Esempio di polimorfismo in PHP

<?php

class User
{
    public $username;
    public $email;

    public function __construct($username, $email)
    {
        $this->username = $username;
        $this->email = $email;
    }
    public function getUsername()
    {
        return $this->username;
    }
    public function getEmail()
    {
        return $this->email;
    }

    public function showInfo()
    {
        echo "Username: " . $this->username . "\n";
        echo "Email: " . $this->email . "\n";
    }
}

class Admin extends User
{
    public $permissions;
    public function __construct($username, $email, $permissions)
    {
        parent::__construct($username, $email);
        $this->permissions = $permissions;
    }
    public function getPermissions()
    {
        return $this->permissions;
    }

    public function showInfo()
    {
        parent::showInfo();
        echo "Permissions: " . $this->permissions . "\n";
    }
}

$user = new User("John Doe", "[email protected]");
$admin = new Admin("Jane Doe", "[email protected]", ["read", "write", "delete"]);

$users = [$user, $admin];

foreach ($users as $user) {
    $user->showInfo();
}

In questo esempio, la classe User e la classe Admin hanno entrambe un metodo showInfo(). Quando il metodo showInfo() viene chiamato su un oggetto, viene richiamata l'implementazione corretta del metodo, in base al tipo dell'oggetto. Questo consente al ciclo foreach di trattare gli oggetti $user e $admin come oggetti dello stesso tipo, anche se sono istanze di classi diverse.

Conclusione

La Programmazione Orientata agli Oggetti (OOP) è un paradigma potente ampiamente utilizzato in PHP per costruire applicazioni web scalabili e manutenibili. Classi e oggetti sono i mattoni fondamentali; incapsulamento, ereditarietà e polimorfismo sono le funzionalità che ti permettono di scrivere codice efficiente e riutilizzabile. Padroneggia questi concetti e il resto del modello a oggetti di PHP diventerà chiaro.

Dove andare dopo:

• PHP Constructor — inizializzare gli oggetti correttamente.
• PHP Access Modifiers — public, protected e private in profondità.
• PHP Inheritance — estendere e sovrascrivere le classi.
• PHP Abstract Classes — definire progetti parziali che le sottoclassi devono completare.
• PHP Interfaces — imporre un contratto condiviso tra classi non correlate.
• PHP Static Methods — metodi che appartengono alla classe piuttosto che a un'istanza.

Esercitazione