Lezione 23: Proprietà e metodi

Esplora le fondamenta della Programmazione Orientata agli Oggetti (OOP) in PHP, imparando a definire e utilizzare proprietà e metodi per creare classi e oggetti robusti e ben strutturati. Questa lezione per principianti ti guiderà attraverso concetti essenziali come l'incapsulamento e l'uso del costruttore.

La programmazione web moderna si basa sempre più su paradigmi che permettono di gestire la complessità in modo efficiente. Tra questi, la Programmazione Orientata agli Oggetti (OOP) è uno dei più diffusi e potenti. In PHP, l'OOP è un pilastro fondamentale per la creazione di applicazioni robuste, scalabili e facili da mantenere. Sebbene all'inizio possa sembrare un concetto astratto, capire le basi dell'OOP, in particolare le proprietà e i metodi, è un passo cruciale per diventare uno sviluppatore PHP competente.

Questa lezione è progettata per i principianti e ti guiderà attraverso i concetti chiave di classi, oggetti, proprietà e metodi, spiegando il loro ruolo e come utilizzarli in PHP. Imparerai non solo cosa sono, ma anche perché sono così importanti per scrivere codice pulito e organizzato. Preparati a scoprire come PHP ti permette di modellare il mondo reale in entità software, rendendo il tuo codice più intuitivo e gestibile.

Cos'è la Programmazione Orientata agli Oggetti (OOP) in PHP?

Prima di addentrarci nelle proprietà e nei metodi, facciamo un passo indietro per capire il contesto. La Programmazione Orientata agli Oggetti (OOP) è un paradigma di programmazione che organizza il software attorno a oggetti anziché a funzioni e logica. Un oggetto è un'istanza di una classe, che può essere vista come un "modello" o uno "stampino" per creare oggetti.

Immagina di voler costruire diverse automobili. Non disegneresti ogni singola automobile da zero. Invece, creeresti un progetto o un "modello" di automobile (la classe), che specifica che ogni automobile avrà un colore, un numero di ruote, un motore, e la capacità di accelerare, frenare, e girare. Poi, da questo modello, potresti costruire quante automobili vuoi (gli oggetti), ognuna con le proprie caratteristiche specifiche (ad esempio, una rossa, una blu, ecc.).

I principi fondamentali dell'OOP includono:

Incapsulamento: Raggruppa i dati (proprietà) e le funzioni che operano su quei dati (metodi) in una singola unità (la classe), nascondendo i dettagli interni dell'implementazione all'esterno. Questo migliora la sicurezza e la modularità del codice.
Ereditarietà: Permette a una classe di ereditare proprietà e metodi da un'altra classe, promuovendo il riutilizzo del codice e creando una gerarchia di classi.
Astrazione: Mostra solo le informazioni essenziali e nasconde i dettagli di implementazione complessi. L'utente interagisce solo con ciò che è rilevante.
Polimorfismo: Permette a oggetti di classi diverse di essere trattati come oggetti di una classe comune, e a un'azione di assumere forme diverse a seconda dell'oggetto che la esegue.

L'adozione dell'OOP porta a numerosi vantaggi, come una maggiore leggibilità e manutenibilità del codice, la possibilità di riutilizzare componenti software e una migliore organizzazione del progetto, specialmente in applicazioni di grandi dimensioni.

Le Classi: Lo Stampino degli Oggetti

In PHP, una classe è il costrutto fondamentale per l'OOP. È una definizione astratta di un "tipo" di oggetto, che descrive quali proprietà (dati) avrà un oggetto di quel tipo e quali metodi (funzioni) potrà eseguire. Non è un oggetto in sé, ma una blueprint da cui gli oggetti vengono creati.

Per dichiarare una classe in PHP, si usa la parola chiave class seguita dal nome della classe. I nomi delle classi in PHP iniziano convenzionalmente con una lettera maiuscola e usano il formato CamelCase (es. NomeClasse, UtenteRegistrato).

<?php

class Automobile {
    // Qui andranno proprietà e metodi
}

// Creare un oggetto (istanza) della classe Automobile
$miaAuto = new Automobile();

// Puoi creare più oggetti dalla stessa classe
$tuaAuto = new Automobile();

?>

Nell'esempio sopra, Automobile è la classe. $miaAuto e $tuaAuto sono oggetti o istanze della classe Automobile. Ogni oggetto è un'entità indipendente, ma entrambi seguono lo stesso "modello" definito dalla classe Automobile.

Le Proprietà: Le Caratteristiche degli Oggetti

Le proprietà (chiamate anche attributi o variabili membro) sono le variabili che appartengono a una classe e descrivono le caratteristiche o lo stato di un oggetto. Riprendendo l'esempio dell'automobile, il colore, la marca, il modello o il numero di ruote sarebbero proprietà.

Quando dichiari una proprietà all'interno di una classe, devi specificare un modificatore di accesso. Questo definisce da dove la proprietà può essere acceduta o modificata. I tre modificatori di accesso principali sono public, protected e private.

public: La proprietà è accessibile da qualsiasi punto del codice, sia dall'interno della classe che dall'esterno (cioè, da qualsiasi oggetto di quella classe).
protected: La proprietà è accessibile solo dall'interno della classe stessa e dalle classi che ereditano da essa (classi figlie).
private: La proprietà è accessibile solo dall'interno della classe in cui è stata definita. Non è accessibile nemmeno dalle classi figlie o dall'esterno.

L'uso di private e protected è fondamentale per l'incapsulamento, poiché ti permette di nascondere i dettagli interni dell'oggetto e di controllare come i suoi dati vengono modificati. Questo previene modifiche indesiderate o incoerenti dello stato interno dell'oggetto.

Ecco come si dichiarano le proprietà:

<?php

class Persona {
    public $nome; // Accessibile da ovunque
    public $cognome;
    protected $dataNascita; // Accessibile solo dalla classe Persona e sue figlie
    private $codiceFiscale; // Accessibile solo dalla classe Persona

    public function __construct($nome, $cognome, $dataNascita, $codiceFiscale) {
        $this->nome = $nome;
        $this->cognome = $cognome;
        $this->dataNascita = $dataNascita;
        $this->codiceFiscale = $codiceFiscale;
    }

    public function getCodiceFiscale() {
        return $this->codiceFiscale; // Metodo interno può accedere a private
    }
}

$mario = new Persona("Mario", "Rossi", "1990-05-15", "MRORSS90E15H501F");

echo $mario->nome; // Output: Mario (public)
// echo $mario->dataNascita; // Errore: Cannot access protected property Persona::$dataNascita
// echo $mario->codiceFiscale; // Errore: Cannot access private property Persona::$codiceFiscale

echo "\
Il codice fiscale di Mario è: " . $mario->getCodiceFiscale(); // Output: Il codice fiscale di Mario è: MRORSS90E15H501F

?>

Nel codice sopra, abbiamo creato una classe Persona con proprietà public, protected e private. Abbiamo dimostrato come le proprietà public siano direttamente accessibili, mentre quelle protected e private non lo siano dall'esterno della classe. Per accedere a una proprietà privata come $codiceFiscale, dobbiamo utilizzare un metodo pubblico della stessa classe (getCodiceFiscale()). Questo è un esempio lampante di incapsulamento in azione.

I Metodi: Le Azioni degli Oggetti

I metodi sono le funzioni che appartengono a una classe e definiscono il comportamento o le azioni che un oggetto di quella classe può eseguire. Se le proprietà descrivono cosa è un oggetto, i metodi descrivono cosa può fare un oggetto. Nell'esempio dell'automobile, "accelerare", "frenare" o "girare" sarebbero metodi.

Come per le proprietà, anche i metodi possono avere modificatori di accesso (public, protected, private) che ne regolano la visibilità e l'accessibilità. La logica dietro i modificatori di accesso è la stessa: public per operazioni che l'esterno può invocare, private per logiche interne che non dovrebbero essere esposte, e protected per funzionalità che le classi figlie possono usare.

All'interno di un metodo, per accedere alle proprietà o ad altri metodi dello stesso oggetto, si usa la parola chiave speciale $this. $this si riferisce all'istanza corrente dell'oggetto.

Ecco come si dichiarano e si usano i metodi:

<?php

class Cane {
    public $nome;
    public $razza;
    private $eta;

    public function __construct($nome, $razza, $eta) {
        $this->nome = $nome;
        $this->razza = $razza;
        $this->eta = $eta;
    }

    public function abbaia() {
        return "Woof woof!";
    }

    public function presenta() {
        // Usiamo $this per accedere alle proprietà dell'oggetto corrente
        return "Ciao, sono " . $this->nome . ", un " . $this->razza . " di " . $this->eta . " anni.";
    }

    private function calcolaEtaUmana() {
        // Un metodo privato, usato solo internamente
        return $this->eta * 7;
    }

    public function getEtaUmana() {
        return "La mia età in anni umani è circa " . $this->calcolaEtaUmana() . ".";
    }
}

$fido = new Cane("Fido", "Labrador", 3);

echo $fido->presenta(); // Output: Ciao, sono Fido, un Labrador di 3 anni.
echo "\
" . $fido->abbaia(); // Output: Woof woof!
echo "\
" . $fido->getEtaUmana(); // Output: La mia età in anni umani è circa 21.

// Tentativo di chiamare un metodo privato dall'esterno (causerà un errore)
// echo $fido->calcolaEtaUmana(); // Errore fatale: Call to private method Cane::calcolaEtaUmana()

?>

In questo esempio, abbaia(), presenta() e getEtaUmana() sono metodi pubblici che possono essere chiamati su un oggetto Cane. Il metodo calcolaEtaUmana() è private, il che significa che può essere chiamato solo da altri metodi all'interno della classe Cane (come getEtaUmana()), ma non direttamente dall'esterno. Questo è un altro esempio di come l'incapsulamento protegga la logica interna dell'oggetto.

Il Costruttore e il Distruttore

Le classi in PHP possono avere metodi speciali, noti come metodi magici, che vengono invocati automaticamente in determinate circostanze. I più comuni per i principianti sono il costruttore (__construct()) e il distruttore (__destruct()).

Il Costruttore (`__construct()`)

Il costruttore è un metodo speciale che viene automaticamente chiamato ogni volta che un nuovo oggetto viene creato dalla classe. Il suo scopo principale è inizializzare le proprietà dell'oggetto con valori di default o con valori passati durante la creazione dell'oggetto. Questo garantisce che l'oggetto sia in uno stato valido fin dal momento della sua creazione.

Se non definisci un costruttore, PHP ne userà uno predefinito che non fa nulla. Ma per oggetti più complessi, è quasi sempre una buona pratica definire un costruttore per assicurarti che tutte le proprietà essenziali siano impostate correttamente.

<?php

class Libro {
    public $titolo;
    public $autore;
    public $annoPubblicazione;

    // Il costruttore accetta parametri per inizializzare le proprietà
    public function __construct($titolo, $autore, $annoPubblicazione) {
        $this->titolo = $titolo;
        $this->autore = $autore;
        $this->annoPubblicazione = $annoPubblicazione;
        echo "Il libro '" . $this->titolo . "' è stato creato.\
";
    }

    public function getDettagli() {
        return "Titolo: " . $this->titolo . ", Autore: " . $this->autore . ", Anno: " . $this->annoPubblicazione;
    }
}

// Quando creiamo un nuovo oggetto Libro, il costruttore viene chiamato automaticamente
$libro1 = new Libro("Il Signore degli Anelli", "J.R.R. Tolkien", 1954);
echo $libro1->getDettagli();

echo "\
";

$libro2 = new Libro("PHP per Principianti", "Mario Rossi", 2023);
echo $libro2->getDettagli();

?>

Come puoi vedere, il costruttore ci permette di passare i valori iniziali direttamente al momento della creazione dell'oggetto, rendendo il codice più pulito e meno propenso a errori rispetto all'impostazione manuale di ogni proprietà dopo la creazione.

Il Distruttore (`__destruct()`)

Il distruttore è un altro metodo magico che viene chiamato automaticamente quando un oggetto non ha più riferimenti (cioè, quando non è più utilizzato e sta per essere rimosso dalla memoria) o quando lo script termina. È utile per eseguire operazioni di pulizia, come chiudere connessioni a database o rilasciare risorse. Tuttavia, per i principianti, è meno comune doverlo implementare, poiché PHP gestisce gran parte della gestione della memoria automaticamente.

<?php

class ConnessioneDatabase {
    public $nomeConnessione;

    public function __construct($nome) {
        $this->nomeConnessione = $nome;
        echo "Connessione '{$this->nomeConnessione}' aperta.\
";
        // Qui andrebbe la logica per aprire una connessione reale
    }

    public function __destruct() {
        echo "Connessione '{$this->nomeConnessione}' chiusa.\
";
        // Qui andrebbe la logica per chiudere la connessione reale
    }
}

$dbConn1 = new ConnessioneDatabase("principale");
$dbConn2 = new ConnessioneDatabase("secondaria");

echo "Lo script sta per terminare...\
";
// Quando lo script termina, i distruttori di $dbConn1 e $dbConn2 verranno chiamati automaticamente.

?>

L'output di questo script mostrerebbe i messaggi di chiusura delle connessioni alla fine, dopo il messaggio "Lo script sta per terminare...".

Esempi Pratici: Costruire una Classe Utente Semplice

Ora mettiamo insieme tutto ciò che abbiamo imparato per creare una classe Utente più completa e realistica, che potrebbe essere usata in una web application.

Questa classe avrà:

Proprietà private per id, nomeUtente, email e passwordHash (per motivi di sicurezza, non memorizziamo la password in chiaro).
Un costruttore per inizializzare queste proprietà.
Metodi public (getter) per recuperare le proprietà (tranne la password).
Metodi public (setter) per modificare nomeUtente ed email, includendo una logica di validazione di base.
Un metodo public per impostare la password, che la hasherà per sicurezza.
Un metodo public per verificare una password data contro l'hash memorizzato.
Un metodo public per mostrare i dettagli dell'utente.

<?php

class Utente {
    private $id;
    private $nomeUtente;
    private $email;
    private $passwordHash; // Memorizziamo l'hash della password, non la password in chiaro

    public function __construct($id, $nomeUtente, $email, $password) {
        $this->id = $id;
        $this->setNomeUtente($nomeUtente); // Uso il setter per eventuale validazione
        $this->setEmail($email);           // Uso il setter per la validazione dell'email
        $this->setPassword($password);     // Uso il setter per hashare la password
    }

    // --- Metodi Getter (Accessori) ---
    public function getId() {
        return $this->id;
    }

    public function getNomeUtente() {
        return $this->nomeUtente;
    }

    public function getEmail() {
        return $this->email;
    }

    // --- Metodi Setter (Mutatori) ---
    public function setNomeUtente($nuovoNomeUtente) {
        if (!empty($nuovoNomeUtente) && strlen($nuovoNomeUtente) >= 3) {
            $this->nomeUtente = $nuovoNomeUtente;
            return true;
        }
        echo "Errore: Il nome utente deve contenere almeno 3 caratteri.\
";
        return false;
    }

    public function setEmail($nuovaEmail) {
        // Validazione email di base
        if (filter_var($nuovaEmail, FILTER_VALIDATE_EMAIL)) {
            $this->email = $nuovaEmail;
            return true;
        }
        echo "Errore: Formato email non valido.\
";
        return false;
    }

    public function setPassword($nuovaPassword) {
        if (strlen($nuovaPassword) >= 8) {
            // Hash della password per sicurezza
            $this->passwordHash = password_hash($nuovaPassword, PASSWORD_DEFAULT);
            return true;
        }
        echo "Errore: La password deve contenere almeno 8 caratteri.\
";
        return false;
    }

    // --- Altri Metodi ---
    public function verificaPassword($passwordInserita) {
        // Verifica se la password inserita corrisponde all'hash memorizzato
        return password_verify($passwordInserita, $this->passwordHash);
    }

    public function mostraDettagli() {
        echo "ID: " . $this->getId() . "\
";
        echo "Nome Utente: " . $this->getNomeUtente() . "\
";
        echo "Email: " . $this->getEmail() . "\
";
        echo "--------------------\
";
    }
}

// --- Utilizzo della classe Utente ---

// Creazione di un nuovo utente
$utente1 = new Utente(1, "alice_dev", "alice@example.com", "PasswordSicura123!");
echo "Utente 1 creato:\
";
$utente1->mostraDettagli();

// Tentativo di creare un utente con dati non validi nel costruttore
$utenteInvalid = new Utente(2, "bob", "bob@invalid", "short"); // Output errori di validazione
echo "\
Utente con dati invalidi (dal costruttore):\
";
$utenteInvalid->mostraDettagli(); // Potrebbe mostrare dati parzialmente non validi se la validazione non blocca la creazione

// Accesso alle proprietà tramite getter
echo "Email di Utente 1: " . $utente1->getEmail() . "\
";

// Modifica delle proprietà tramite setter
echo "\
Aggiornamento dati per Utente 1:\
";
if ($utente1->setNomeUtente("alice_pro")) {
    echo "Nome utente aggiornato con successo.\
";
}
if ($utente1->setEmail("alice.pro@example.com")) {
    echo "Email aggiornata con successo.\
";
}
if ($utente1->setPassword("NuovaPasswordForte456!")) {
    echo "Password aggiornata con successo.\
";
}
$utente1->mostraDettagli();

// Tentativo di aggiornare con dati non validi
if (!$utente1->setEmail("email_non_valida")) {
    echo "Tentativo di impostare email non valida bloccato.\
";
}

// Verifica della password
echo "\
Verifica password per Utente 1:\
";
if ($utente1->verificaPassword("NuovaPasswordForte456!")) {
    echo "Accesso riuscito per Utente 1!\
";
} else {
    echo "Password errata per Utente 1.\
";
}

if ($utente1->verificaPassword("vecchiaPassword")) {
    echo "Accesso riuscito con vecchia password (errore)!\
";
} else {
    echo "Password errata (corretto) per Utente 1.\
";
}

?>

Questo esempio mostra come proprietà private, costruttori, getter e setter lavorino insieme per creare un oggetto Utente robusto e sicuro. La logica di validazione all'interno dei setter garantisce che i dati dell'oggetto rimangano sempre in uno stato valido, e l'hashing della password è cruciale per la sicurezza.

Incapsulamento: Proteggere i Dati degli Oggetti

Abbiamo già toccato l'argomento, ma è fondamentale ribadire l'importanza dell'incapsulamento. L'incapsulamento è il principio per cui i dettagli interni di un oggetto (le sue proprietà e i metodi ausiliari) sono nascosti all'esterno. Solo l'interfaccia pubblica dell'oggetto (i suoi metodi public) è esposta e utilizzabile da altri pezzi di codice.

Perché è importante l'incapsulamento?

Integrità dei Dati: Impedisce che i dati interni di un oggetto vengano modificati in modo incontrollato o inconsistente dall'esterno. Ad esempio, se un'età non può essere negativa, un setter incapsulato può controllare questo vincolo.
Manutenibilità: Quando i dettagli interni sono nascosti, puoi modificare l'implementazione interna di una classe senza influenzare il codice che la usa, a patto che l'interfaccia pubblica rimanga la stessa. Questo rende il codice più facile da mantenere e refactorizzare.
Modularità: Ogni oggetto diventa una "scatola nera" che svolge un compito specifico. Questo migliora la modularità del codice e lo rende più facile da capire e testare.
Sicurezza: Come visto con la password, l'incapsulamento permette di gestire dati sensibili in modo controllato, esponendo solo ciò che è strettamente necessario.

I getter (metodi che iniziano con get e restituiscono il valore di una proprietà) e i setter (metodi che iniziano con set e permettono di modificare il valore di una proprietà, spesso con validazione) sono l'implementazione più comune dell'incapsulamento in PHP. Ti permettono di avere un controllo granulare su come le proprietà dell'oggetto vengono lette e scritte.

Errori Comuni e Suggerimenti

Quando si inizia con le proprietà e i metodi, è facile inciampare in alcuni errori comuni. Esserne consapevoli ti aiuterà a evitarli:

Dimenticare $this->: Questo è forse l'errore più frequente per i principianti. All'interno di un metodo di una classe, per accedere a una proprietà o chiamare un altro metodo dello stesso oggetto, devi sempre usare $this->. Senza, PHP cercherà una variabile locale o una funzione globale, il che porterà a errori o comportamenti inaspettati.
```
// Errato
class Esempio {
    public $messaggio = "Ciao";
    public function mostra() {
        echo $messaggio; // Errore: $messaggio non è definito localmente
    }
}

// Corretto
class EsempioCorretto {
    public $messaggio = "Ciao";
    public function mostra() {
        echo $this->messaggio; // OK
    }
}
```
Confondere proprietà e variabili locali: Le proprietà sono dichiarate all'interno della classe (con un modificatore di accesso) e appartengono all'oggetto. Le variabili locali sono dichiarate all'interno di un metodo e esistono solo per la durata di quella chiamata al metodo.
Accesso diretto a proprietà private o protected dall'esterno: Come abbiamo visto, tentare di accedere a $oggetto->proprietaPrivata al di fuori della classe causerà un errore fatale. Usa sempre i getter o i metodi pubblici per interagire con lo stato interno dell'oggetto.
Non istanziare un oggetto (new): Non puoi chiamare metodi o accedere a proprietà di una classe senza prima averne creato un'istanza. Classe::metodo() o Classe::$proprieta esistono, ma sono per membri statici, un concetto avanzato che vedremo in seguito.
Errori di sintassi nel costruttore: Ricorda che il costruttore deve essere chiamato __construct (due underscore, poi construct). Errori di battitura impediranno a PHP di riconoscerlo come metodo speciale.
Non gestire i valori di ritorno dei setter: Se un setter restituisce true o false per indicare il successo o il fallimento della validazione, è buona pratica controllare questo valore e reagire di conseguenza, come mostrato nell'esempio della classe Utente.

Suggerimenti:

Nomi chiari: Dai nomi significativi alle tue classi, proprietà e metodi. Questo rende il tuo codice più leggibile e auto-documentante.
Inizia semplice: Non cercare di creare classi super complesse all'inizio. Inizia con classi piccole che modellano un singolo concetto e aggiungi complessità gradualmente.
Pratica, pratica, pratica: L'OOP richiede un cambio di mentalità. L'unico modo per padroneggiarla è scrivere molto codice e sperimentare.

Prossimi Passi: Verso l'OOP Avanzata

Congratulazioni! Hai coperto le basi fondamentali della Programmazione Orientata agli Oggetti in PHP, comprendendo il ruolo cruciale di classi, oggetti, proprietà, metodi, costruttori e il principio dell'incapsulamento. Questi concetti sono la spina dorsale di quasi tutte le applicazioni PHP moderne.

Per continuare il tuo percorso nell'OOP, i prossimi passi logici includono l'esplorazione di:

Ereditarietà: Come le classi possono estendere altre classi per riutilizzare il codice e creare gerarchie.
Interfacce: Contatti che una classe deve rispettare, definendo quali metodi deve implementare.
Classi Astratte: Classi che non possono essere istanziate direttamente ma servono come base per altre classi.
Metodi e Proprietà Statiche: Membri di una classe che appartengono alla classe stessa, non a una singola istanza dell'oggetto.
Traits: Un meccanismo per il riutilizzo del codice in PHP che supera alcune limitazioni dell'ereditarietà singola.
Namespace: Per organizzare le classi e prevenire conflitti di nomi in progetti di grandi dimensioni.

Ti incoraggio a sperimentare con gli esempi forniti, modificarli e creare le tue classi. Prova a modellare oggetti del mondo reale (come prodotti di un e-commerce, impiegati di un'azienda, o elementi di un gioco) usando proprietà e metodi. Più pratichi, più questi concetti diventeranno naturali. L'OOP è una competenza preziosa che ti aprirà le porte a framework PHP come Laravel, Symfony e molti altri, dove l'approccio orientato agli oggetti è pervasivo. Buon proseguimento nel tuo viaggio di apprendimento PHP!