Il concetto dell'ereditarietà, è uno dei più importanti della programmazione orientata agli oggetti, a cui si appoggiano altri metodi avanzati di programmazione come ad esempio il Polimorfismo o le Classi Astratte che tratteremo nei capitoli seguenti.

L'ereditarietà ci consente di creare delle classi (classi derivate o sottoclassi) basate su classi già esistenti (classi base o superclassi).

Un grande vantaggio è quello di poter riutilizzare il codice di una classe di base senza doverlo modificare.

L'ereditarietà ci consente quindi di scrivere del codice molto più flessibile, in quanto permette una generalizzazione molto più forte di un concetto, rendendo più facile descrivere una situazione di vita reale.

Pensate alla classe base come ad un oggetto che descrive un concetto generale, e pensate invece alle sottoclassi come ad una specializzazione di tale concetto, esteso mediante proprietà e metodi aggiuntivi.

Imparare a programmare utilizzando questi concetti è un passo fondamentale per costruire applicazioni di un certo livello.

Vediamo ora un esempio dove definiremo una classe base e di seguito due derivate (sottoclassi) attraverso la parola chiave extends.
Segue la definizione della classe madre (base) :

Animale.php

<?php

	class Animale // Classe Base
	{
		public $zampe;
		public $ordine;
		public $nome;

		public function Animale($z, $o, $n) // Costruttore
		{
			$this->zampe = $z;
			$this->ordine = $o;
			$this->nome = $n;
		}

		protected function stampaDati() // Metodo protetto : può essere richiamato solo dalle classi derivate
		{ echo $this->nome . " : Zampe = " . $this->zampe . " / Ordine = " . $this->ordine; }
	}

?>

Cane.php

<?php

	require_once("Animale.php");

	class Cane extends Animale // "Sottoclasse" o "Classe Derivata"
	{
		public function Cane() // Costruttore classe derivata
		{
			parent::Animale(4, "Vertebrati", "Cane"); // Chiamata al costruttore della classe madre

			/* oppure più generalizzato

			parent::__construct(4, "Vertebrati", "Cane"); */
		}

		public function stampaDati($suono)
		{
			echo "Faccio $suono perchè sono ";
			parent::stampaDati(); // Chiamata al metodo protetto della classe madre
		}
	}

?>

Gallina.php

<?php

	require_once("Animale.php");

	class Gallina extends Animale // "Sottoclasse" o "Classe Derivata"
	{
		public function Gallina() // Costruttore classe derivata
		{
			parent::Animale(2, "Vertebrati", "Gallina"); // Chiamata al costruttore della classe madre
		}

		public function stampaDati($suono)
		{
			echo "Faccio $suono perchè sono ";
			parent::stampaDati(); // Chiamata al metodo protetto della classe madre
		}
	}

?>

Ora vediamo un frammento di codice dove utilizziamo le classi appena dichiarate :

test.php

<?php

	require_once("Cane.php");
	require_once("Gallina.php");

	$cane = new Cane();
	$cane->stampaDati("bau");

	echo "\n\n<br /><br />\n\n";

	$gallina = new Gallina();
	$gallina->stampaDati("chicchirichì");

?>

Alano.php

<?php

	require_once("Cane.php");

	class Alano extends Cane
	{
		private $suono;

		public function Alano()
		{
			parent::Cane();
			$this->suono = "wuoff";
		}

		public function stampaDati()
		{
			parent::stampaDati($this->suono);
			echo " / Razza : Alano";
		}
	}

?>

test.php

<?php

	require_once("Alano.php");

	$cane = new Alano();
	$cane->stampaDati();

?>

Il nuovo risultato ottenuto.

Nota : PHP non supporta l'ereditarietà multipla, offrendoci come alternativa le Interfacce.

PHP 5 ci consente di definire delle costanti all'interno delle classi.
L'utilizzo è simile alle costanti globali descritte nel nono capitolo di questa guida.

Potete pensare alle costanti delle classi, come a degli attributi statici che non possono però essere modificati una volta dichiarati e definiti.

Prendiamo nuovamente in esempio la vecchia classe "Colore" esaminandone un utilizzo con le costanti :

Colore.php

<?php

	class Colore
	{
		const ROSSO = "#FF0000";
		const VERDE = "#00FF00";
		const BLU = "#0000FF";

		static public function stampaRosso()
		{
			echo "<font color=\"" . self::ROSSO . "\">Il valore esadecimale del colore rosso è : ";
			echo self::ROSSO . "</font><br />\n";
		}
	}

?>

test.php

<?php

	require_once("Colore.php");

	echo Colore::ROSSO . "<br />\n";
	Colore::stampaRosso();

?>

test.php produce questo risultato.

Introdurrò ora uno dei concetti più importanti di PHP 5 : gli Oggetti.

La programmazione orientata agli oggetti è alla base di ogni applicazione solida e potente, e ci consentirà di scrivere del codice estremamente flessibile ed elastico, facendoci risparmiare talvolta anche ore ed ore di lavoro.

Possiamo pensare ad un oggetto come ad un tipo di dato più complesso e personalizzato, non esistente fra i tipi tradizionali di PHP, ma bensì ideato e creato da noi.

Lo scopo è quello di creare un tipo di dato più complesso, per soddisfare richieste che potremo comunque adempiere con i tipi tradizionali, ma con molta meno difficoltà e tempo.

Gli oggetti sono formati principalmente da attributi e metodi.

Gli attributi sono delle variabili proprietarie dell'oggetto, semplici o complesse, quindi anche Array o Oggetti.

I metodi invece, sono delle funzioni proprietarie dell'oggetto, e fra questi ce ne sono due molto importanti :
i Costruttori e i Distruttori.

Se non definirete un costruttore e un distruttore per la vostra classe (oggetto), PHP li rimpiazzerà con dei metodi propri di default, in quanto questi due metodi sono essenziali per il corretto fuzionamento della classe.

Il costruttore verrà chiamato automaticamente da PHP, ogni volta che verrà creato un oggetto (istanza), mentre il distruttore sarà chiamato quando l'oggetto verrà distrutto, ossia quando non esiste più alcun riferimento all'oggetto oppure alla fine dello script.

Per dichiarare un costruttore, è sufficiente creare una funzione all'interno della classe che abbia lo stesso nome di quest'ultima, oppure potete usare la parola chiave __construct().

Nell'esempio che segue creeremo un nuovo tipo di dato, l'oggetto "Persona", con gli attributi "nome", "cognome" e "data di nascita" e il metodo "stampaPersona()" per visualizzare i dati sul browser. Per creare la nuova classe utilizzeremo il costrutto del linguaggio class :

Persona.php

<?php

	class Persona
	{
		public $nome = ""; // attributo
		public $cognome = ""; // attributo
		public $datanascita = ""; // attributo

		public function Persona($n_nome, $n_cognome, $n_data) // costruttore
		{
			$this->nome = $n_nome;
			$this->cognome = $n_cognome;
			$this->datanascita = $n_data;
		}

		public function stampaPersona() // metodo
		{
			echo "Nome : " . $this->nome . "<br />\n";
			echo "Cognome : " . $this->cognome . "<br />\n";
			echo "Data di nascita : " . $this->datanascita . "<br />\n";
		}
	}

?>

Ricordate sempre che in questi casi, il simbolo del dollaro $, va solo su this e non sul nome dell'attributo/metodo, a meno che non si stia usando il metodo delle variabili funzione, di cui discuteremo la variante per oggetti nei prossimi capitoli.

Infine troviamo il metodo stampaPersona() che semplicemente stampa gli attributi dell'oggetto tramite il costrutto echo.

La parola chiave public sarà illustrata nel prossimo capitolo assieme a protected e private.

Ora vedremo come creare ed utilizzare un'istanza dell'oggetto "Persona" dichiarato nella pagina precedente.

test.php

<?php require_once("Persona.php"); ?>
<html>

	<head>
		<title>Test</title>
	</head>

	<body>
	<?php

		$utente = new Persona("Mario", "Rossi", "10-01-1980");
		$utente->stampaPersona();

	?>

	</body>
</html>

Public, Protected e Private

Di seguito una breve descrizione di public e le sue varianti protected e private :

• public - I membri (attributi o metodi) della classe dichiarati public, possono essere utilizzati sia all'interno che all'esterno della classe madre e di quelle derivate da essa (ereditarietà) ($this->membro oppure $oggetto->membro)
• protected - I membri dichiarati protected, possono essere utilizzati solo all'interno delle classi madri e derivate ($this->membro)
• private - I membri dichiarati private, possono essere utilizzati solo all'interno della classe madre ($this->membro)

Tornando alla classe "Persona", poichè abbiamo dichiarato gli attributi come public, il linguaggio ci consente di agire direttamente su di essi, senza dover richiamare il costruttore ogni volta che dobbiamo modificare un attributo dell'istanza ($utente) :

$utente = new Persona("John", "Doe", "1-1-1970");

$utente->nome = "Santiago";
$utente->cognome = "Arnavisca";

$utente->stampaPersona(); // output = Nome : Santiago / Cognome : Arnavisca / Data di nascita : 1-1-1970

Se invece avessimo usato la restrizione private per gli attributi della classe "Persona", avremmo ricevuto dal server il seguente errore sollevato dalla riga $utente->nome = "Santiago";
Fatal error: Cannot access private property Persona::$nome in C:\AppServ\www\test\test.php

Avremmo ottenuto un errore equivalente anche utilizzando il modificatore di accesso protected, in quanto protected stabilisce che l'attributo o metodo così dichiarato, può essere utilizzato solo all'interno della classe, ma a differenza di private, ne consente l'utilizzo anche nelle classi derivate, argomento che tratteremo più avanti nel capitolo della Ereditarietà.