PHP - Incapsulamento

L'incapsulamento è uno dei principi fondamentali della programmazione orientata agli oggetti (OOP). Si riferisce all'unione di dati con i metodi che operano su quei dati. In PHP, l'incapsulamento può essere raggiunto utilizzando classi e modificatori di accesso come public, private e protected. Questo tutorial ti guiderà attraverso i fondamentali dell'incapsulamento in PHP, iniziando con i membri public, poi passando ai membri private e infine coprendo i membri protected.

Membri Public

I membri public sono accessibili da ovunque, sia all'interno che all'esterno della classe. Vengono dichiarati utilizzando la parola chiave public. Ecco un esempio di una semplice classe con un membro public:

class Car {
    public $color;

    public function setColor($color) {
        $this->color = $color;
    }

    public function getColor() {
        return $this->color;
    }
}

$myCar = new Car();
$myCar->setColor("rosso");
echo "La mia auto è " . $myCar->getColor() . "."; // Output: La mia auto è rosso.

In questo esempio, abbiamo una classe Car con una proprietà public $color e due metodi public setColor() e getColor(). Possiamo facilmente impostare e ottenere il colore dell'auto dall'esterno della classe.

Membri Private

I membri private sono accessibili solo all'interno della classe in cui sono definiti. Vengono dichiarati utilizzando la parola chiave private. Ecco un esempio di una classe con un membro private:

class BankAccount {
    private $balance;

    public function __construct($initialBalance) {
        $this->balance = $initialBalance;
    }

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

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

$myAccount = new BankAccount(100);
$myAccount->deposit(50);
echo "Il mio saldo del conto è " . $myAccount->getBalance() . "."; // Output: Il mio saldo del conto è 150.

In questo esempio, abbiamo una classe BankAccount con una proprietà private $balance e due metodi public deposit() e getBalance(). La proprietà $balance non è direttamente accessibile dall'esterno della classe, ma possiamo manipolarla utilizzando il metodo deposit() e recuperare il suo valore utilizzando il metodo getBalance().

Membri Protected

I membri protected sono accessibili all'interno della classe in cui sono definiti e anche all'interno di qualsiasi sottoclasse. Vengono dichiarati utilizzando la parola chiave protected. Ecco un esempio di una classe con un membro protected:

class Animal {
    protected $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

class Dog extends Animal {
    public function bark() {
        echo "Woof! Sono " . $this->name . ".";
    }
}

$myDog = new Dog("Buddy");
$myDog->bark(); // Output: Woof! Sono Buddy.

In questo esempio, abbiamo una classe Animal con una proprietà protected $name. La classe Dog estende la classe Animal e ha accesso alla proprietà $name perché è protected. Possiamo utilizzare la proprietà $name all'interno della classe Dog per implementare il metodo bark().

Conclusione

L'incapsulamento è un concetto cruciale nell'OOP che aiuta a mantenere l'integrità dei dati limitando l'accesso diretto ad essi. Utilizzando modificatori di accesso come public, private e protected, puoi controllare come i tuoi dati vengono accessibili e modificati. Comprendere l'incapsulamento ti aiuterà a scrivere codice più robusto e manutenibile in PHP e in altre lingue OOP.

Credits: Image by storyset