Le classi astratte

Nelle ultime lezioni proposte da questa trattazione abbiamo analizzato i concetti basilari dell’ereditarietà in PHP. In questo capitolo tratteremo invece delle classi astratte, le quali ricoprono un ruolo fondamentale nella programmazione orientata agli oggetti (OOP).

Cosa sono le classi astratte (abstract class)

Una classe astratta è definibile come un particolare tipo di classe la quale non può essere istanziata, cioè non è possibile creare un oggetto da una classe astratta, ma può solo essere estesa da un'altra classe.

Possiamo considerare una classe astratta come una superclasse, in cui è possibile aggiungere uno o più metodi astratti i quali dovranno essere (necessariamente) ridefiniti da una sottoclasse per poter essere utilizzati. Quindi, quando si aggiunge un metodo astratto in una classe astratta, non si inserisce nessun codice all'interno del metodo, da qui la definizione di "metodo senza corpo"; al contrario, si lascia l'implementazione del metodo alle classi figlie che ereditano dalla classe astratta.

Per questo motivo possiamo considerare questa tipologia di classe come una "base di partenza" o "modello" per la creazione di classi.

Una classe derivata da una classe astratta, per poter essere istanziata, deve implementare tutti i metodi astratti della classe astratta; se non lo facesse, costringerebbe PHP a generare un errore). Nello specifico, una classe astratta è contrassegnata dalla parola chiave abstract nella dichiarazione della classe e in tutti i metodi. a tal proposito si osservi l'esempio seguente:

<?php
// definizione della classe astratta Person
// una classe astratta può contenere metodi normali e metodi astratti.
abstract class Person {
	private $name = "";
	private $lastname = "";
	public function setName($name, $lastname) {
		$this->name = $name;
		$this->lastname = $lastname;
	}
	public function getName() {
		return "$this->name $this->lastname";
	}
	abstract public function viewHello();
}
?>

Nell'esempio, abbiamo dichiarato la classe astratta Person, aggiungendo la parola chiave abstract prima della definizione di classe. La classe contiene due proprietà $name e $lastname, così come i metodi, setName e getName (ereditati dalle classi figlie), per impostare e recuperare queste proprietà.

La classe Person, contiene anche un metodo astratto, viewHello, per la visualizzazione di un messaggio di benvenuto. Siccome parliamo di un metodo astratto, si tratta soltanto di una dichiarazione e non contiene nessuna implementazione.

Come detto in precedenza, una classe astratta non può essere istanziata. In altre parole, non è consentito creare una nuova istanza di una classe astratta. Infatti, provando ad istanziare la classe Person avremo un risultato come il seguente:

<?php
...
$p = new Person('Giuseppe','Rossi');
...
?>

dove viene generato un errore di runtime interrompendo l'esecuzione dello script:

Fatal error: Cannot instantiate abstract class Person in [...]

Ora potremo creare la nostra classe Employees la quale eredita da Person

<?php
// definizione della sottoclasse Employees
class Employees extends Person {
	public function viewHello() {
		echo "Hello " . $this->getName()."<br>";;
	}
	function setId($id_rif) {
		$this->id_rif = $id_rif;
	}
}
// oltre a chiamare setId() è possibile richiamare getName() e setName(),
// dal momento che questi metodi sono ereditati dalla classe astratta Person
$employee = new Employees();
$employee->setName( "Giuseppe", "Rossi" );
$employee->viewHello();
$employee->setId(7);
?>

Come possiamo vedere, la nostra classe, implementa il metodo astratto viewHello di Person, più un metodo standard setId(). Questo è e l'output visualizzato dopo l'esecuzione dello script:

Hello Giuseppe Rossi

Dichiarando Employee senza la definizione di viewHello(), avremmo ottenuto il seguente errore:

Fatal error: Class Employees contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Person::viewHello) in  [...]

Conclusioni

Con questa lezione abbiamo descritto le modalità con cui utilizzare le classi astratte per capirne l'importanza. Nella prossima lezione verranno descritte delle ulteriori astrazioni delle classi astratte: le interfacce.