Continuiamo la trattazione sulla programmazione a oggetti introducendo il nuovo argomento che si chiama Overloading.Si tratta di una particolare tecnica della programmazione a oggetti che permette di ridefinire all’interno dei prgrammi un metodo che precedentemente era gia’ stato definito in una delle sue classi, con lo scopo di abbandonare il comportamento iniziale e sostiturilo con un altro piu’ specifico. . Ma vediamo subito un esempio pratico.
La programmazione a Oggetti in PHP
<?php
class motociclo
{
public function accendi()
{
print ("sto partendo con il mio motociclo");
$this -> partito = true;
}
class scooter extends motociclo
{
public function accendi()
{
print ("parto con lo scooter");
$this -> partito = true;
}
}
?>
<html>
<body>
$motociclo = new motociclo();
$motociclo -> accendi();
$scooter = new scooter();
$scooter -> accendi();
?>
</body>
</html>Se mandiamo in esecuzione lo script otteniamo
sto partendo con il mio motociclo
parto con lo scooter
Vediamo adesso come utilizzare i metodi della superclasse nel caso di overloading.
<?php
class veicolo
{
public $motoreacceso;
public function __construct()
{
print ("Questo è il mio nuoovo veicolo");
$this->motoreacceso = false;
}
pubblic function accendi()
{
print ("Accendo il motore del mio veicolo e mi preparo a partire");
$this ->motoreacceso=true;
}
}
class auto extends veicolo
{
public function __construct()
{
parent::__construct()
print("il mio veciolo è un 'atoveicolo nuovo di zecca");
}
public function accendi()
{
parent::accendi();
print("sto proprio girando la chiave nel quadro in questo preciso momento");
$this->motoreacceso =true;
}
}
?>
<html>
<body>
<?php
$veicolo = new veicolo();
$veicolo -> accendi();
$auto = new auto();
$auto -> accendi ("Mario");
?>
</body>
</html>
Se mandiamo in esecuzione il seguente script otteniamo
Questo è il mio nuovo veicolo
Accendo il motore del mio veicolo e mi preparo a partire
Questo è il mio nuovo veicolo
il mio veciolo è un ‘atoveicolo nuovo di zecca
Accendo il motore del mio veicolo e mi preparo a partire
sto proprio girando la chiave nel quadro in questo preciso momento
Ma facciamo subito una precisazione, un attributo statico puo’ essere richiamato attraverso la sintassi
nomeclasse::$nomeattributo nomeclasse::nomemetodo()
Come si è potuto vedere in questa serie di esempi per accedere a componenti statici di una classe si utilizza l’operatore :: al posto del classico operatore freccia. L’utilizzo di questa sintassi pemette di specificare al motore PHP che l’oggetto che si sta referenziando è statico per la classe che si è indicata e non c’è bisogno di istanziare un oggetto.
$oggetto -> metodo(); $oggetto -> attributo; nomeclasse::metodo(); nomeclasse::attributo;
Per referenziare una classe che contiene membri statici non si utilizza la parola riservata this bensi’ si utilizza self, vediamo giusto un messaggio di esempio
public static function getgeneric()
{
self::incrementa();
return self::$incrementa;
}in parole povere è solamente un cambio di sintassi con la parola self al posto di this.Affrontiamo adesso l’argomento della clonazione. E’ una tecnica che permette di creare un nuovo oggetto sulla base di tutte le informazioni presenti in un altro, ossia tutti i metodi e tutti gli attributi.
Vediamo il solito esempio.
<?php
class motociclo
{
// membri e metodi di motociclo
public function __construct(//lista membri e metodi)
{
//Istruzioni
}
....
.....
}
?>
<html>
<body>
<?php
$motoveicolo1 = new motoveicolo ->__clone();
...
....
?>
</html>
</body>
E’ proprio clone la parola chiave , dunque a questo punto possiamo affermare che la parola chiave a cui si ricorre per effettuare la clonazione è
__clone()
Le Interfacce in PHP
Affrontiamo adesso l’ultimo argomento e probabilmente il piu’ controverso della programmazione a oggetti ossia le Interfacce che sono una tecnica di programmazione che permettono di definire lo scheletro completo di una classe, i nome dei metodi, i parametri e i tipi dei valori prodotti dai metodi , non contiene codice , ma soltanto la descrizione di quali siano e come siano fatti i metodi che dovranno successivamente essere implementati dalle classi che vorranno “implementare l’interfaccia”
Facciamo un esempio per comprendere
interface forma
{
abstract function area();
abstract function perimetro();
}a questo punto non ci rimane che definire la classe
class poligono {
public $altezza;
public $larghezza;
function __construct (£altezza, $larghezza)
{
$this -> altezza =$altezza;
$this -> larghezza = $larghezza
}
}
a questo punto creiamo l’intefaccia , che altro non è che il collegamento fra i due scritp di cui sopra.
class rettangolo extends poligono implements forma
fucntion area()
{
return ($this->altezza * $this -> larghezza);
}
function perimetro ()
{
return ((2* $this->altezza) + (2 *$this ->larghezza();
}
}a questo punto non ci rimane che andare nella parte dedicata all’html e scrivere qualcosa del tipo per ottenere il risultato
…..
<body>
<?php
$ret = new rettangolo (10,6);
print ("Rettangolo : altezza =" .$ret->altezza."larghezza" .$ret->larrghezza);
print ("area:". $ret->area());
?>
</body>
</html>E ovviamente avremo stampato l’area a video che in questo caso corrisponde a 60 e con questo abbiamo concluso anche questa lezione che riguardava la programmazione a oggetti dalla prossima lezione iniziero con il database.