PHP  »  Guide  »  Guida Programmazione a Oggetti PHP 5 

In tutte le precedenti lezioni, abbiamo sempre analizzato una classe per volta, che incapsula funzionalità centralizzate e permette di dare vita ad un numero illimitato di istanze. Tuttavia, il vero cuore della OOP nasce tramite le gerarchie di classi: è possibile fare in modo che una classe estenda un'altra classe e da essa ne erediti le funzionalità.

Per attuare questo interessante procedimento, occorre utilizzare la parola chiave extends unita ai nomi della classe che estende (sottoclasse, a sinistra) e della classe che viene estesa (superclasse, destra): SubClass extends SuperClass. Vediamo subito un esempio pratico:

class A {

        public $a = 10;
        public $b = 20;
        
        public function get_a() {
                return $this->a;
        }

}

class B extends A {
        
        public function get_b() {
                return $this->b;
        }

}

$b = new B;
echo $b->a;                     // stampa 10
echo $b->get_a();       // stampa 10
echo $b->get_b();       // stampa 20

Come possiamo notare, la classe B, estendendo la classe A, guadagna tutte le proprietà pubbliche ed i metodi pubblici offerti da quest'ultima. Ciò significa che le istanze della classe B avranno a disposizione le proprietà a (10) e b (20) ed i metodi get_a (ereditato dalla classe A) e get_b. Tramite il precedente snippet, abbiamo creato una gerarchia formata da due classi.

Attuando questo principio, è possibile condividere e separare le funzionalità in più classi ed usufruire così dei vantaggi fondamentali della OOP: modularità ed estensibilità.

Ingrandire la gerarchia

Ovviamente, non si è limitati alla presenza di due sole classi all'interno delle nostre gerarchie, ma possiamo includere il numero di classi desiderato. Le sottoclassi avranno a disposizione tutte le componenti pubbliche (e protette, come vedremo nella prossima lezione dedicata agli indicatori di visibilità) delle classi antenate ed offriranno le proprie alle relative sottoclassi:

class C extends B {

        public $c = 30;
        
        public function get_c() {
                return $this->c;
        }

}

class DE extends C {

        public $d = 40;
        public $e = 50;
        
        public function get_d() {
                return $this->d;
        }
        
        public function get_e() {
                return $this->e;
        }

}

$c = new C;
echo $c->get_b();       // stampa 20
echo $c->get_c();       // stampa 30

$de = new DE;
echo $de->get_a();      // stampa 10
echo $de->get_b();      // stampa 20
echo $de->get_c();      // stampa 30
echo $de->get_d();      // stampa 40
echo $de->get_e();      // stampa 50

Come vedremo nella lezione dedicata all'overriding, sarà inoltre possibile ridefinire i metodi delle superclassi implementando nuove funzionalità e richiamare le funzionalità dei metodi antenati aventi stesso namespace, tramite la keyword parent o il nome della classe uniti dall'operatore di risoluzione dell'ambito ("::") con il nome del metodo.

Conclusione

L'estensione delle classi e la formulazione di gerarchie sono il vero nucleo della programmazione ad oggetti, nonché uno dei suoi principali vantaggi. Tramite la condivisione delle risorse è infatti possibile creare applicazioni estensibili, modulari e mantenibili. Ma in una classe non si vorrà sempre condividere tutte le risorse presenti al suo interno con l'esterno o con le rispettive sottoclassi: proprio per questo motivo nascono gli indicatori di visibilità (di cui abbiamo già avuto un assaggio tramite la keyword public), che analizzeremo nella prossima lezione e che consentono di decidere quali risorse condividere o, in parole semplificate, chi può vedere e accedere a che cosa.

Altri articoli

Altre guide

Altre newsletter