Utilizzare le interfacce

Dopo avere acquisito la conoscenza delle teorie e delle sintassi che stanno alla base delle interfacce, passiamo ora ad analizzare uno scenario reale in cui queste ultime vengono utilizzate.

Assumiamo, come nell'esempio dedicato alle classi astratte, che un Team di sviluppatori denominato "A" stia lavorando ad una classe User che permette di creare un utente e gestire le sue caratteristiche, mentre il Team "B", utilizzando le stesse regole, vuole aggiungere funzionalità leggermente più avanzate personalizzate, come il counting degli utenti e dei messaggi testuali. Entrambe le classi, per ottenere una struttura comune, implementano l'interfaccia denominata IUser:

interface IUser {
        public function getName();
        public function setName($name);
        public function getAge();
        public function setAge($age);
        public function setPartner($user);
}

Ecco la classe UserA definita dal gruppo "A":

class UserA implements IUser {
        // proprietà
        public $name;
        public $age;
        // costruttore
        public function __construct($name, $age) {
                $this->name = $name;
                $this->age = $age;
        }
        // metodi
        public function getName() {
                return $this->name;
        }
        public function setName($name) {
                $this->name = $name;
        }
        public function getAge() {
                return $this->age;
        }
        public function setAge($age) {
                $this->age = $age;
        }
        public function setPartner($user) {
                if($user instanceof IUser) $this->partner = $user;
        }
} 
// creazione di nuovi utenti
$user = new UserA("Alfred", 48);
$user2 = new UserA("Sonia", 40);
// settiamo "Sonia" come il partner di "Alfred"
$user->setPartner($user2);

Questa è l'implementazione desiderata dal Team "A". Ora ecco la controparte del Team "B":

class UserB implements IUser {
        // proprietà
        public $name;
        public $age;
        public static $usersB = 0;
        // costruttore
        public function __construct($name, $age) {
                $this->name = $name;
                $this->age = $age;
                ++self::$userB;
                echo "Users "B" created: " . self::$userB;
        }
        // metodi
        public function getName() {
                return "The name of this user is " . $this->name;
        }
        public function setName($name) {
                $this->name = $name;
                return "Name set to " . $this->name;
        }
        public function getAge() {
                return "This user is " . $this->age . " years old";
        }
        public function setAge($age) {
                $this->age = $age;
                return "Age set to " . $this->age;
        }
        public function setPartner($user) {
                if($user instanceof IUser) {
                        $this->partner = $user;
                        return "Partner of " . $this->name . " set to " . $this->partner;
                }
        }
} 
// creazione di nuovi utenti
$user = new UserB("Alfred", 48); // "Users "B" created: 1"
$user2 = new UserB("Sonia", 40); // "Users "B" created: 2"
// settiamo "Sonia" come il partner di "Alfred"
// stampa "Partner of Alfred set to Sonia"
$user->setPartner($user2);

Come possiamo notare, la classe UserB è leggermente più complessa e nutrita rispetto alla classe UserA: la prima tiene traccia di quanti utenti sono stati creati e stampa dei messaggi ad ogni operazione, sia di getting che di setting. Ciò che conta però, è che entrambe le classi hanno una forma comune, sia le istanze della classe UserA che quelle della classe UserB possono essere intercambiate ed integrate nella stessa applicazione senza produrre incompatibilità o errori.

Inoltre, dato che entrambe le classi implementano l'intefaccia IUser, è possibile tramite i metodi setPartner di ognuna, impostare un partner di tipo UserA ad un'istanza di tipo UserB e vice versa.

Conclusione

Anche in questo caso, come in quello delle classi astratte, non si deve pensare che basti utilizzare delle interfacce per ottenere applicazioni prive di ogni instabilità, ma occorre prestare attenzione a tutte le fasi dello sviluppo del progetto. Le classi astratte e le interfacce, se usate adeguatamente, possono portare enormi benefici alle nostre gerarchie OOP.

Con questa ultima lezione dedicata alle interfacce si chiude la sezione dedicata all'astrazione della classi. A questo punto della guida, si è già molto probabilmente acquisita la capacità di creare gerarchie solide e conformi ai punti chiave della OOP. Tuttavia, esistono ancora diversi concetti che devono essere appresi per otternere una conoscenza a 360 gradi, che per la loro natura eteroegenea non possono essere raggrupati in una sezione comune. Per questo, nella prossima suddivisione di lezioni (chiamata Extra) saranno appunto affrontati tutti gli extra offerti dalla programmazione orientata agli oggetti di PHP, a partire dai riferimenti degli oggetti.