Classi PHP: costrutti della pro­gram­ma­zio­ne orientata agli oggetti

Le classi PHP or­ga­niz­za­no il codice in moduli logici in­di­pen­den­ti, ciascuno con ca­rat­te­ri­sti­che e metodi specifici. Questo favorisce la gestione e il riu­ti­liz­zo del codice in progetti complessi.

Cosa sono le classi PHP?

Le classi PHP sono come modelli o schemi usati per creare oggetti. In una classe vengono definite le ca­rat­te­ri­sti­che (variabili o attributi) e i metodi (funzioni) da assegnare a un de­ter­mi­na­to oggetto. Le classi sono fon­da­men­ta­li nella pro­gram­ma­zio­ne orientata agli oggetti e possono essere combinate con altre funzioni PHP. È possibile creare classi anche per estrarre dati da un database MySQL.

Come definire le classi PHP

Per definire una classe in PHP si inizia con la parola chiave class, seguita dal nome de­si­de­ra­to per la classe, rac­chiu­den­do il testo tra parentesi graffe. All’interno delle parentesi graffe possiamo definire le proprietà e i metodi della classe.

class Name {
    // php class example properties and methods
}

Di seguito un esempio concreto:

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}

La classe “Animal” possiede due attributi, “name” e “color” insieme a due metodi, (set_name) per impostare il nome e (get_name) per re­cu­pe­rar­lo.

Qual è la relazione fra classi e oggetti in PHP?

Gli oggetti sono istanze di una classe. Istan­zian­do una classe si crea un oggetto che può accedere alle proprietà e ai metodi definiti nella classe stessa. I nuovi oggetti di una classe vengono istan­zia­ti uti­liz­zan­do la parola chiave new.

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}
$dog = new Animal();
$cat = new Animal();
$dog->set_name('Tom');
$cat->set_name('Mickey');
echo $dog->get_name();
echo "<br>";
echo $cat->get_name();

In questo esempio “dog” e “cat” sono istanze della classe “Animal”, alle quali as­se­gnia­mo un nome.

In aggiunta, le classi PHP possono essere ereditate, il che significa che è possibile creare una nuova classe de­ri­van­do­la da una già esistente. La classe figlio eredita tutte le proprietà e i metodi della classe padre, il che permette di riu­ti­liz­za­re e ampliare le varie funzioni. Allo stesso tempo gli oggetti della classe figlio sono istanze della classe base e possono accedere ai suoi metodi.

class Mammal extends Animal {
function breathesAir() {
      echo "inhale";
    }
}
$horse = new Mammal;
$horse->setName("Louis");

Uti­liz­zan­do la parola chiave extends, la classe figlio “Mammals” eredita tutte le proprietà e i metodi dalla classe padre “Animal”. È possibile ag­giun­ge­re nuove funzioni a “Mammal” ma allo stesso tempo accedere alle funzioni ereditate.

Esempi di utilizzo di classi PHP

Le classi PHP possono essere uti­liz­za­te in molti modi. Di seguito il­lu­stria­mo alcuni esempi pratici.

PHP in­stan­ceof

In PHP, in­stan­ceof è un operatore che permette di ve­ri­fi­ca­re se un oggetto ap­par­tie­ne a una classe specifica o a una classe derivata da essa.

Di seguito un esempio di facile com­pren­sio­ne:

class Animal {
    public function speak() {
        echo "sound";
    }
}
class Dog extends Animal {
    public function speak() {
        echo "bark";
    }
}
$animal = new Dog();
if ($animal instanceof Animal) {
    $animal->speak(); // Output: "bark"
}

Anzitutto, si utilizza l’operatore in­stan­ceof per ve­ri­fi­ca­re se la variabile $animal è un’istanza della classe PHP “Animal” o di una delle sue classi figlie. Poiché $animal è un’istanza della classe derivata “Dog” (ereditata da Animal), la con­di­zio­ne risulta vera e viene eseguito il codice all’interno del blocco “if”.

L’utilizzo dell’operatore instanceof è par­ti­co­lar­men­te utile quando si desidera as­si­cu­rar­si di poter accedere a metodi o proprietà specifici senza generare errori nel caso in cui l’oggetto non presenti la classe de­si­de­ra­ta.

Classi e array PHP

Le classi possono essere salvate in array PHP. Questo consente di pro­get­ta­re strutture di dati complesse.

class Product {
    public $name;
    public $price;
    public function __construct($name, $price) {
        $this->name = $name;
        $this->price = $price;
    }
}
$products = [
    new Product("Laptop", 800),
    new Product("Smartphone", 400),
    new Product("Tablet", 300)
];
foreach ($products as $product) {
    echo "Product: " . $product->name . ", Price: $" . $product->price . “<br>";
}

In questo esempio creiamo la classe “Product” per rap­pre­sen­ta­re diversi prodotti e suc­ces­si­va­men­te li ar­chi­via­mo nell’array “products”. Quindi possiamo uti­liz­za­re un mec­ca­ni­smo di foreach per sot­to­por­re l’array a cicli PHP per vi­sua­liz­za­re i nomi e i prezzi dei prodotti.

Co­strut­to­re di classi PHP

Il co­strut­to­re è un metodo PHP all’interno di una classe che viene ri­chia­ma­to au­to­ma­ti­ca­men­te quando si crea un oggetto di quella classe. Il compito prin­ci­pa­le di un co­strut­to­re è ini­zia­liz­za­re un oggetto o eseguire altre ope­ra­zio­ni pre­pa­ra­to­rie ne­ces­sa­rie per garantire che l’oggetto funzioni cor­ret­ta­men­te.

class Dog {
    private $name;
    private $color;
    // Constructor
    public function __construct($name, $color) {
        $this->name = $name;
        $this->color = $color;
    }
    public function sayHello() {
        return "Hello, my name is {$this->name} and my color is {$this->color}.";
    }
}
$dog = new Dog("Tom", "brown");
echo $dog->sayHello(); // Output: "Hello, my name is Tom and my color is brown."