Le classi di PhP

La definizione di una classe avviene utilizzando una sintassi predefinita. In primo luogo il costruttore della classe deve chiamarsi __construct; in secondo luogo abbiamo la possibilità di definire dei distruttori (implementati nel metodo __destruct) che verranno chiamati ogni qualvolta il garbage collector di PHP distruggerà l'oggetto. E' possibile specificare la visibilità di metodi ed attributi attraverso le parole chiave public, protected e private. Esempio di classe:

Codice:

<?php
class Prova
{
    public $attr_public;
    private $attr_private;
    protected $attr_protected;

    public function __construct()
    {
        // operazioni di inizializzazione
    }

    public function __destruct()
    {
        // operazioni eseguite prima della distruzione
    }

    public function publicMethod()
    {
    }

    protected function protectedMethod()
    {
    }
 
  private function privateMethod()
    {
    }
}
?>

E' possibile (e necessario) specificare esplicitamente quali metodi o proprietà dovranno essere statiche. Solo le proprietà o i metodi statici possono essere acceduti utilizzando l'operatore :: .

Si puo' sfruttare la possibilità di definire la visibilità di metodi e proprietà per facilitare il design dell'applicazione.

Codice:

<?php
class ExtProva extends Prova
{
    public function __construct()
    {
        parent::__construct();
    }
   
    private function provaProtected()
    {
        $this-> protectedMethod();
    }
}
?>

Vi sono inoltre le interfacce. Un'interfaccia è una classe speciale che definisce solamente la struttura che dovranno obbligatoriamente avere le classi che la implementano. Non può essere istanziata.
Se una classe non dovesse implementare tutti i metodi definiti nell'interfaccia, PHP restituirebbe un errore.

Codice:

<?php
interface ProvaInterfaccia
{
    public function mustBeImplemented();
}

class Prova implements ProvaInterfaccia
{
    public function mustBeImplemented()
    {
        // implementazione
    }
}
?>

Le classi astratte invece sono un sistema che permette di definire classi parzialmente completate che lasciano l'implementazione di alcuni metodi alle sottoclassi. Una classe astratta deve essere definita utilizzando la parola chiave abstract; lo stesso vale per quei metodi astratti della classe.

Codice:

<?php
abstract class ProvaAbs
{
    public function prova()
    {
        $this->abstractMethod();
    }

    abstract protected function  abstractMethod();
}
class Prova extends ProvaAbs
{
    protected function  abstractMethod()
    {
        // metodo richiamato da ProvaAbs::prova()
    }
}
?>

Grazie alle interfacce ed alle classi astratte, PHP ha rafforzato notevolmente il suo supporto ai tipi di dato, permettendo l'introduzione del type hinting per i tipi di dato complessi. Possiamo specificare il tipo di oggetto che ci aspettiamo per un parametro di un metodo/funzione demandando a PHP il compito di effettuare il controllo:

Codice:

<?php
function prova(ProvaAbs $arg)
{
    $arg->prova();
}
?>

In questo modo possiamo assicurarci un'integrità delle chiamate che prima era quasi impossibile se non con particolari controlli effettuati a runtime.
E' inoltre possibile definire costanti di classe, accedendovi utilizzando l'operatore usato per le proprietà o i metodi statici:

Codice:

<?php
class Prova
{
    const MIA_COSTANTE = 'valore';
}
echo Prova::MIA_COSTANTE;
?>

PHP richiama automaticamente la funzione __autoload quando non trova una classe. Un aggiunta che permette di caricare automaticamente i file contenenti le definizioni delle classi nel momento in cui non vengano trovate in fase di esecuzione:

Codice:

<?php
function __autoload($classname)
{
    echo Classe richiesta: .$classname;
    require_once $classname..php;
}
$prova = new Prova();
?>

E' possibile definire dei metodi particolari per catturare tutte le richieste in lettura/scrittura alle proprietà e le chiamate ai metodi, nel caso non fossero trovati nell'albero dei simboli di una classe:

Codice:

<?php
class Prova
{
    public $prova;
    private $data;

    public function __construct()
    {
        $this->data = array();
    }

    public function __set($name, $value)
    {
        echo Scritta la proprietà .$name.<br/>;
        $this->data[$name] = $value;
    }

    public function __get($name)
    {
        echo Richiesta la proprietà .$name.<br/>;
        return $this->data[$name];
    }
 
    public function test()
    {
        echo test method;
    }

    public function __call($name, $args)
    {
        echo Richiamato il metodo .$name. con .count($args). argomenti;
    }
}

$prova = new Prova;
$prova->prova = 10;
echo $prova->prova;
$prova->ciao = ciao;
echo $prova->ciao;
$prova->metodoInesistente(1, 2, 3, 4, array());
?>

Il pattern Iterator.

Un iteratore è un oggetto che si comporta come una lista da cui è possibile recuperare ciclicamente gli elementi, con la differenza che la lista non è (normalmente) già salvata in memoria ma gli elementi successivi a quello corrente vengono generati su richiesta. Questo permette iterazioni su liste virtualmente infinite o di cui non si conoscono a priori le dimensioni. Gli iteratori possono essere utilizzati in congiunzione con il costrutto foreach come se si trattasse di normali array.

Codice:

<?php
class MiaListaIterator implements Iterator
{
    private $array;
    private $valid;
 
    public function __construct($array)
    {
        $this->array = $array;
        $this->valid = false;
    }

    public function rewind()
    {
        $this->valid = (FALSE !== reset($this->array));
    }

    public function current()
    {
        return current($this->array);
    }

    public function key()
    {
        return key($this->array);
    }

    public function valid()
    {
        return $this->valid;
    }

    public function next()
    {
        $this->valid = (FALSE !== next($this->array));
    }
}

class MiaLista implements IteratorAggregate
{
    private $range;

    public function __construct($max)
    {
        $this->range = range(0, $max);
    }

    public function getIterator()
    {
        return new  MiaListaIterator($this->range);
    }
}

$prova = new MiaLista(500);
foreach($prova as $item)
{
    echo $item.<br />;
}
?>

Le interfaccee Iterator ed IteratorAggregate. La prima serve per permettere a PHP di assicurarsi che l'iteratore recuperato segua una struttura precisa che permette di operare sull'elemento come se fosse un array (recuperando la chiave corrente, il prossimo elemento, l'elemento corrente, o riavvolgendo), mentre la seconda serve per assicurarsi che ogni oggetto utilizzato da foreach come un'array possa restituire un iteratore in modo corretto, tramite getIterator.

The End!