PHP 5.x: Panoramica sulla programmazione orientata agli oggetti

[Master85]

Introduzione

Lo sviluppo di applicazioni web complesse, ha rappresentato per molto tempo, una complicata organizzazione del codice sorgente e di conseguenza anche una difficile manutenzione delle applicazioni. Il primo approccio ad una programmazione orientata agli oggetti viene introdotto dalla versione 3.x di PHP, anche se il linguaggio non era del tutto OO, la tecnica offriva allo sviluppatore esperto, gia' abituato a lavorare in OO, con Java o C++, di organizzare meglio il proprio lavoro, individuando gli oggetti da utilizzare, le proprieta' ed i vari metodi per il corretto funzionamento del programma. Una volta organizzato il lavoro in questo modo, lo sviluppo, non risultava molto complicato e si poteva visualizzare un modello ben definito dell'applicazione come un buon punto di riferimento per la stesura del codice sorgente.
In questi ultimi anni le molte esigenze dei programmatori hanno portato ad uno sviluppo piu' completo per la OOP in ambiente PHP, difatti gli autori dello Zend Engine 2.0, sul quale si basa il nuovo PHP 5, offrono una programmazione orientata agli oggetti molto simile al Java e al C++. Anche se gli ambienti presentino evidenti analogie, non possiamo affermare che le tecniche siano identiche. Ogni linguaggio di programmazione presenta le proprie convenzioni ed illustra le proprie tecniche di gestione OOP.

Dalla programmazione procedurale agli oggetti...

Il mondo dei programmatori e' principalmente suddiviso in due categorie, ben distinte e separate, la programmazione procedurale e la programmazione orientata agli oggetti. C'e' chi sostiene le tecniche legate alla programmazione procedurale e chi no. Ma allora, qual e' la tecnica migliore ? Fornire una risposta valida, a questa domanda, non e' molto complicato, "Questione di punti di vista", gia', tutto risiede nel modo in cui il programmatore stesso identifica i vari punti dell'applicazione da sviluppare, decidendo in seguito una migliore organizzazione del codice.
Ovviamente, l'approccio OO permette una migliore visione del problema ed una migliore gestione ed organizzazione del codice, la tecnica puo' essere definita *piu' pulita* rispetto all'approccio procedurale, poiche' consente di ridistribuire il codice a terze parti che a loro volta potrebbero migliorarlo e ampliarlo nelle sue funzioni, un altro punto di forza della tecnica OO e' la possibilita' di riutilizzare lo stesso codice in altre situazioni, ed infine, le analogie con i Database Relazionali sono molte, ma di questo ne parleremo in seguito.
Dunque, la visione ad oggetti e' completamente differente dal codice procedurale ? La risposta e' si. Di seguito viene visualizzato un grafico che mostra come la stessa soluzione possa offrire due scenari differenti in base ai punti di vista, Procedure contro Oggetti:



Come si nota facilmente, la tecnica della programmazione orientata agli oggetti permette di definire a priori una Classe generica da cui ricavare tutti gli oggetti di cui abbiamo bisogno e successivamente gestirli, e questo e' uno dei tanti vantaggi che la OOP propone a discapito dell'approccio procedurale che, a sua volta, impone la creazione di dati e codice per la manipolazione degli stessi, per ciascuno degli elementi da gestire. Se ci fermiamo un attimo e riflettiamo su quanto detto e visto, possiamo facilmente dedurre quanto sia *fastidioso* lavorare per via procedurale anziche' ad oggetti, senza parlare poi, di codice prolisso. Ovviamente, l'esempio della "macchina" proposto e' semplice, ma se pensassimo a come gestire e attuare una manutenzione in applicazioni di grosse dimensioni sviluppate per via procdedurale, stiamo pur certi che ci penseremo ben piu' di due volte prima di prendere il lavoro.

Migrare dalle procedure agli oggetti...

...Anche se potrebbe sembrare *traumatico*, una volta appreso il concetto *base* della OOP sara' del tutto automatico il passaggio a questo stile di *vita*. Difficile, sara' il contrario. Ovviamente e' questione di casi, non sempre e' necessario ricorrere agli oggetti. Ad esempio se dovessimo realizzare un semplice sito internet che non richieda molto codice e di conseguenza poca interattivita' con l'utente, come "gallerie fotografiche", "news" e altri piccoli sistemi ancora, non sara' necessario scomodare la OOP. La programmazione orientata agli oggetti viene spesso utilizzata nello sviluppo di grosse applicazioni e per lo piu' in presenza di un vero e proprio staff di lavoro, dove ciascuno dedichera' parte del suo tempo allo sviluppo di sezioni diverse. Di conseguenza, la programmazione orientata agli oggetti, offre anche uno strumento valido e potente per l'organizzazione del lavoro di gruppo e dell'applicazione stessa, specialmente se quest'ultima si basa appunto, su basi di dati relazionali, dove ogni tabella rappresentera' una entita' del mondo reale e quindi un potenziale oggetto.

Le tecniche della OOP ed il Web

Siamo giunti alla parte piu' importante di questo articolo, qui, cercheremo di capire come la programmazione orientata agli oggetti possa essere integrata nel web e come il web gestisca questa tecnica. Il lettore esperto in OOP dovrebbe tenere conto di questo paragrafo.

La persistenza dei dati

Tra le applicazioni Desktop e le applicazioni Web, esiste una sostanziale differenza riguardante la persistenza dei dati nel tempo. Le applicazioni Desktop sono software residenti sulle nostre macchine (in locale) e di conseguenza occupano parte della memoria dei nostri PC, cio' significa che nella RAM verranno mantenuti nel tempo alcuni dati importanti per il corretto funzionamento della stessa applicazione. Se pensiamo ad un'applicazione sviluppata in Java, residente sul nostro PC, che fa uso della programmazione orientata agli oggetti, sicuramente alcuni oggetti creati dall'applicazione saranno soggetti ad evoluzioni e sicuramente saranno presenti in memoria per ore, giorni o mesi, se non di piu'. Tutto dipende dal tipo di applicazione che stiamo utilizzando. In questo caso possiamo certamente affermare che questo e' un *corretto* utilizzo della OOP, in effetti uno dei tanti vantaggi di questa tecnica e' proprio permettere la persistenza degli oggetti nel tempo, consentendone anche una certa evoluzione ed interazione tra di loro.
Il concetto di persistenza dei dati sul Web e' totalmente differente dalle applicazioni Desktop, in quanto le stesse applicazioni non risiedono sulle nostre macchine, ma su Server Web Remoti. La funzione di un Server Web e' quello di generare risultati in base alle richieste pervenute dai Client. I risultati, nella maggior parte dei casi, riguardano la generazione di pagine web che avviene dopo una elaborazione dei dati in ingresso (dal client). Spesso, i Server Web sono soggetti alla elaborazione e alla generazione di risultati da parte di piu' Clients, pensiamo ad un web server che gestisca piu' di 500 richieste contemporaneamente. Sarebbe impensabile immagazzinare tutti i risultati ottenuti, nella RAM, cio' significherebbe un utilizzo di risorse hardware dispendioso. Per ovviare a questo problema, la maggior parte dei web server, scarica la memoria ogni volta che un risultato (pagina) viene generato, di conseguenza tutti i dati elaborati e/o gli oggetti creati verranno distrutti.
Per questo motivo, quando di parla di applicazioni Web e al concetto della persistenza dei Dati non possiamo fare riferimento alla RAM del server, ma ad altri tipi di soluzioni. Il problema lagato alla persistenza dei dati sul Web e' stato risolto per mezzo di diverse tecniche messe a disposizione nel PHP 5, ovvero, dalla serializzazione e dalla deserializzazione degli oggetti, che consentono, rispettivamente, di convertire l'oggetto creato in una equivalente stringa di dati per essere successivamente memorizzata in un Database oppure in un file, e di riconvertire la stringa in un oggetto, simulando in questo modo la persistenza dei dati, utilizzando un Database o un file, come RAM. Di questo argomento ne parleremo in un successivo articolo.

L' Object oriented ed il PHP 5

Fino ad ora si e' introdotto il concetto di OOP e delle differenze legate alle applicazioni Desktop con le applicazioni Web. Da questo paragrafo in poi analizzeremo le maggiori caratteristiche riguardanti l'OOP ed il PHP 5. La lettura e' consigliata a programmatori che hanno gia' lavorato in OO mediante altri lingauggi di programmazione e intendono aggiornarsi a questo nuovo linguaggio:

• Ereditarieta' singola
  Allo stesso modo di Java, PHP 5 permette di ereditare una definizione di classe "figlio" da una sola classe "padre" mediante la clausola extends, di conseguenza si parla di eredita' singola. Una classe ereditata' presentare gli stessi attributi e gli stessi metodi della classe "padre".
  
• Costruttori
  A differenza della versione precedente, PHP 5 sostituisce il classico metodo per definire costruttori all'interno di ogni classe attraverso la funzione __construct(), mentre in passato, si procedeva con assegnare ad una funzione lo stesso nome della classe per essere interpretato da PHP come costruttore. Gli stessi sviluppatori dello Zend Engine 2.0, pur garantendo la retro-compatibilita' con le versioni precedenti del linguaggio, consigliano di utilizzare questa nuova metodologia per definire i costruttori. Da evidenziare inoltre, che i costruttori delle classi "padri" non vengono chiamati automaticamente dalle classi "figlie", ma e' necessario chiamarli esplicitamente.
  
• Distruttori
  Complementari dei costruttori, i distruttori permettono di eseguire varie operazioni di pulizia ogni volta che un oggetto viene scaricato dalla memoria, quindi ne viene terminata l'esecuzione. Si richiama all' interno di ogni classe mediante la funzione __destruct() ed il suo utilizzo spesso cade sulle varie operazioni legate alla chiusura di connessione verso i database, eliminazione di dati temporanei oppure allo svuotamento di variabili globali e cosi' via.
  
• Incapsulamento
  In questa nuova versione del PHP e' stato interamente introdotto il concetto di incapsulamento permettendo di modificare la visibilita' degli attributi e dei metodi mediante l'utilizzo l'utilizzo delle clausole public, private e protected.
  
• Polimorfismo e Overloading
  Purtroppo, questa release del PHP non ci permette di gestire l'overloading di funzioni ed inoltre come polimorfismo viene inteso l'utilizzo di istanze di classe figlio al posto di classi genitore. COmunque, vedremo come simulare un overloading di funzioni mediante altre tecniche.
  
• Classi astratte
  Tra gli aggiornamenti piu' significativi, lo Zend Engine 2.0 ci permette di dichiarare delle definizioni di classe in modo Astratto mediante la nuova clausola abstract. Concetto gia' conosciuto dagli sviluppatori Java e C++. Ricordiamo che le classi astratte non possono essere istanziate ma esclusivamente ereditate.
  
• Interfacce
  Un altro interessante aggiornamento riguarda l'intergrazione delle interfacce. Le interfacce sono spesso utilizzate durante lo sviluppo di grandi progetti per "standardizzare" i nome di metodi che dovranno svolgere le stesse funzioni. Per dichiarare un'interfaccia si utilizza la clausola interface. Mentre per implementarla in una classe si utilizza la sintassi seguente: class mia_classe implements mia_interfaccia, di conseguenza, la classe "mia_classe" dovra' presentare un metodo con lo stesso nome dichiarato precedentemente all'interno dell'interfaccia. In seguito verranno proposti alcuni esempi per capirne meglio il concetto.
  
• Introspezione
  Le funzioni di introspezione proposte da questa nuova versione del PHP, permettono di recuperare informazioni utili riguardanti i nomi delle classe, l'elenco degli attributi ed informazioni importanti sulle funzioni.

OOP in pratica

Nel paragrafo precedente si e' discusso sulle caratteristiche principali legate alla OOP introdotte da questo nuovo linguaggio. In questo paragrafo si cerchera' di fornire esempi pratici riguardanti la gestione della OOP, partendo dalla dichiarazione di una semplice classe e finendo alle varie tecniche per la introspezione.

Dichiarazione di Classe

File: automobile.php (1° Versione / 1° Parte - dichirazione di classe)

Codice PHP:

<?php
//Dichiarazione di classe Automobile
class automobile{
    //Dichiarazione degli Attributi
    var $colore;
    var $velocita_corrente = 0;
    var $velocita_frenatura = 5;
    var $velocita_accelerazione = 10;
    var $velocita_min = 0;
    var $velocita_max = 100;
    var $i = 1;
    
    //Dichiarazione dei Metodi
    function accelera($volte){
        if(is_int($volte)){
            while($this->i <= $volte && $this->velocita_corrente < $this->velocita_max){
                    $this->i++;
                    $this->velocita_corrente += $this->velocita_accelerazione;
            }
            //Azzero $i
            $this->i = 1;
        }else{
            print("specificare un valore numerico intero");
        }
    }
    
    function frena($volte){
        if(is_int($volte)){
            while($this->i <= $volte && $this->velocita_corrente > $this->velocita_min){
                $this->i++;
                $this->velocita_corrente -= $this->velocita_frenatura;
            }
        }else{
            print("specificare un valore numerico intero");
        }
    }
}
//...

Dichiarazione di una istanza di classe (oggetto)

File: automobile.php (1° Versione / 2° Parte - istanziare un oggetto)

Codice PHP:

//...

//Dichiaro un'istanza della classe automobile
$myAuto = new automobile;
$myAuto->accelera(2); //accelero di 2, quindi siamo a 20 km/h
$myAuto->accelera(6); //accelero di 6, quindi siamo a 80 km/h
$myAuto->frena(15);        //freno di 15, quindi sono siamo a 5 km/h
print($myAuto->velocita_corrente." km/h");
?> 


Ereditarieta'

File: automobile.php (2° Versione / 1° Parte - dichiarazione di una classe figlia)

Codice PHP:

<?php
<?php
//Dichiarazione di classe Automobile
class automobile{
    //Dichiarazione degli Attributi
    var $colore;
    var $velocita_corrente = 0;
    var $velocita_frenatura = 5;
    var $velocita_accelerazione = 10;
    var $velocita_min = 0;
    var $velocita_max = 100;
    var $i = 1;
    
    //Dichiarazione dei Metodi
    function accelera($volte){
        if(is_int($volte)){
            while($this->i <= $volte && $this->velocita_corrente < $this->velocita_max){
                    $this->i++;
                    $this->velocita_corrente += $this->velocita_accelerazione;
            }
            //Azzero $i
            $this->i = 1;
        }else{
            print("specificare un valore numerico intero");
        }
    }
    
    function frena($volte){
        if(is_int($volte)){
            while($this->i <= $volte && $this->velocita_corrente > $this->velocita_min){
                $this->i++;
                $this->velocita_corrente -= $this->velocita_frenatura;
            }
        }else{
            print("specificare un valore numerico intero");
        }
    }
}

//Dichiarazione di classe Automobile_Sportiva ereditata da Automobile
class automobile_sportiva extends automobile{
    //Ridefizione di alcuni attributi
    //Chiamata a costruttore
    function __construct(){
        $this->velocita_frenatura = 20;
        $this->velocita_accelerazione = 20;
        $this->velocita_max = 200;
    }
}

//...

Dichiarazione di una instanza di classe ereditata

Codice PHP:

//...
//Dichiaro un'istanza della classe automobile_sportiva
$myAuto = new automobile_sportiva;
$myAuto->accelera(2); //accelero di 2, quindi siamo a 40 km/h
$myAuto->accelera(6); //accelero di 6, quindi siamo a 160 km/h
$myAuto->frena(5);        //freno di 15, quindi sono siamo a 60 km/h
print($myAuto->velocita_corrente." km/h");
?> 


Incapsulamento

A questo punto si dovrebbe migliorare il codice sorgente della classe genitore "automobile", modificando la visibilita' degli attributi all'interno delle classi stesse, ricorrendo quindi alla tecnica dell'incapsulamento, o meglio ancora della visibilita'. Fornire esempi specifici per la classe automobile potrebbe risultare complicato da capire e probabilmente non renderebbe bene l'idea di visibilta'. Per questo motivo, i vari esempi che verranno proposti di seguito cercano di illustrare al meglio l'argomento della visibilita', mediante porzioni di codice semplici e di facile interpretazione.
Uno degli aspetti su cui si basa il principio della programmazione orientata agli oggetti e' proprio la visibilita' degli attributi e dei metodi all'interno ed all'esterno delle classi. In PHP 4, accade che tutti gli attributi e tutti i metodi siano di tipo Public (pubblici) di conseguenza si ha il libero accesso e quindi la modifica dei dati all'interno della classe, violando di conseguenza uno dei principali aspetti della OOP. L'argomento della visibilita' e' stato completamente rivisitato e migliorato in PHP 5, con l'introduzione dei modificatori: Public, Protected e Private.
La visibilita' per tutti i metodi e per tutti gli attributi, ove non specificato e' di tipo pubblico, di conseguenza anche se non viene specificato il modificatore Public, gli attributi ed i metodi saranno accessibili dall'esterno e soggetti a modifiche. A differenza invece del modificatore Protected che consente l'accessibilita' agli attributi ed ai metodi, soltando dall'interno della classe stessa o da classi figlie, ma non dall'esterno. Infine, come ultimo livello, abbiamo il modificatore Private, quindi Privato, il quale consente l'accesso a metodi o attributi, esclusivamente dall'interno della classe stessa, escludendo gli accessi da classi figlie e dall'esterno. Solitamente i modificatori Protected e Private sono necessari per migliorare la sicurezza e l'efficienza dei dati all'interno della classe, negando cosi' l'acccesso dall'esterno e prevenire codice corrotto.
Di seguito viene visualizzato il listato di un semplice esempio, il cui compito sara' quello di rendere meglio l'idea sull'utilizzo dei modificatori:

File: incapsulamento.php (Codice sorgente completo)

Codice PHP:

<?php
class incapsulamento{

    public function MetodoPubblico(){
    
        print("Metodo Pubblico<br />");
            
    }
    
    protected function MetodoProtetto(){
    
        print("Metodo Protetto<br />");
        
        /**
         * In questo caso posso richiamare
         * il Metodo privato: "MetodoPrivato()"
         * Poiche' la chiamata avviene dalla stessa classe
         */
         
         $this->MetodoPrivato();
             
    }
    
    private function MetodoPrivato(){
        
        print("Metodo Privato");
                
    }

}

class secondo_incapsulamento extends incapsulamento{

    /**
     * Imposto un metodo Pubblico
     * per chiamarlo dall'esterno
     */

    public function chiamaAltriMetodi(){
    
        /**
         * Qui posso richiamare i due metodi:
         * 1. MetodoPubblico()
         * 2. MetodoProtetto()
         * Ma non il metodo privato: "MetodoProtetto()"
         */
        
        $this->MetodoPubblico();
        $this->MetodoProtetto();
    }

}

//Istanzio il primo oggetto
$primo_oggetto = new incapsulamento;

//Corretto: Cerco di chiamare il metodo pubblico
$primo_oggetto->MetodoPubblico();

//Sbagliato: Cerco di chiamare il metodo protetto
//Fatal error: Call to protected method incapsulamento::MetodoProtetto() ...
//$primo_oggetto->MetodoProtetto();

//Sbagliato: Cerco di chiamare il metodo privato
//Fatal error: Call to private method incapsulamento::MetodoPrivato() from ...
//$primo_oggetto->MetodoPrivato();

//Istanzio un secondo oggetto che eredita dalla prima classe
$secondo_oggetto = new secondo_incapsulamento;

/**
 * Corretto: Chiamo un metodo pubblico
 * che a sua volta chiama un metodo protetto ed un altro pubblico
 * dalla stessa classe, quindi, OK ;-)
 */
 
$secondo_oggetto->chiamaAltriMetodi();
?>

Ovviamente il concetto di visibilita' si estende anche per gli attributi.

Classi astratte e Interfacce

Classi Astratte

Le classi atratte sono utilizzate per definire dei veri e propri propotipi di classe, definendo metodi e attributi standard per tutte le classi figlie. Inoltre le classi astratte non potranno essere istanziate come oggetti, ma potranno presentare a loro interno anche metodi concreti che verranno ereditati dalle sotto-classi, in aggiunta ovviamente dei metodi astratti, i quali, una volta dichirati nella classe astratta, dovranno necessariamente essere implementati all'interno delle sotto-classi. L'operatore utilizzato per definire classi e metodi astratti e': abstract. Da ricordare, che ogni sotto-classe puo' ereditare da una sola classe astratta.
Di seguito viene visualizzato un semplice esempio, che riprende la metodologia utilizzata durante lo sviluppo di videogames RPG per definire le classi dei vari personaggi disponibili, distinguendo ogni tipologia di personaggio con metodi differenti.

File: Classe_astratta.php (1° parte - definizione della classe astratta "personaggio")

Codice PHP:

<?php
abstract class personaggio{
        protected $log;
        
        protected $nome;
        protected $altezza;
        protected $peso;
        protected $forza;
        
        /**
         * Metodi concreti della classe astratta
         */
        public function setPersonaggio($nome, $altezza, $peso, $forza){
            $this->nome = $nome;
            $this->altezza = $altezza;
            $this->peso = $peso;
            $this->forza = $forza;
        }
        
        public function showPersonaggio(){
            echo("<br />Nome: $this->nome");
            echo("<br />Altezza: $this->altezza");
            echo("<br />Peso: $this->peso");
            echo("<br />Forza: $this->forza");
        }
        
        public function showLog(){
            echo("<br />Log per $this->nome: $this->log");
        }
        
        /**
         * Metodo astratto: killPersonaggio
         * Ogni personaggio muore in un certo modo
         */
        abstract function killPersonaggio();
}

...

File: File: Classe_astratta.php (2° parte - definizione delle classi concrete "guerriero" e "mago")

Codice PHP:

...

//Personaggio guerriero
class guerriero extends personaggio{
    /**
     * Inizializzazione personaggio
     */
    public function __construct(){
        $this->log .= "<br />Personaggio guerriero creato !\n";
    }
    
    /**
     * Implemento il metodo: killPersonaggio
     */
    public function killPersonaggio(){
        //Qui, altre operazioni...
        echo("<br />Il guerriero $this->nome muore gloriosamente !");
        //Aggiorno il log del personaggio
        $this->log .= "<br />Il personaggio $this->nome e' morto !";
    }
}

//Personaggio mago
class mago extends personaggio{
    /**
     * Inizializzazione personaggio
     */
    public function __construct(){
        $this->log .= "<br />Personaggio mago creato !\n";
    }
    
    /**
     * Implemento il metodo: killPersonaggio
     */
    public function killPersonaggio(){
        //Qui, altre operazioni...
        echo("<br />Il mago $this->nome muore, tutti gli altri personaggi perdono 5 punti vita !");
        //Aggiorno il log del personaggio
        $this->log .= "<br />Il personaggio $this->nome e' morto !";
    }
}

... 


File: File: Classe_astratta.php (3° parte - Esempio pratico)

Codice PHP:

...

//Avvio il test dell'esempio
//Creo un personaggio di tipo Guerriero
$mioGuerriero = new guerriero;
$mioGuerriero->setPersonaggio('Aragon', 180, 90, 10);
$mioGuerriero->showPersonaggio();
$mioGuerriero->killPersonaggio();
$mioGuerriero->showLog();

//Creo un personaggio di tipo Mago
$mioMago = new mago;
$mioMago->setPersonaggio('Merlino', 168, 67, 6);
$mioMago->showPersonaggio();
$mioMago->killPersonaggio();
$mioMago->showLog();
?> 


Interfacce

Le interfacce riprendono sostanzialmente tutte le regole viste nel paragrafo precedente, relative alle classi astratti, a differenza dell'operatore, che in questo caso verra' individuato dalla parola interface. All'interno di queste classi tutti i metodi saranno esclusivamente di tipo "public" e "abstract", inoltre, le sotto-classi potranno implementari piu' interfacce. Perche' ? La spiegazione di questa soluzione e' dovuta proprio all'impiego vero e proprio delle interfacce, che, vengono utilizzate durante lo sviluppo di grossi progetti, in cui, gli sviluppatori devono attenersi a determinate linee guida per l'utilizzo di nomi per i metodi "generalizzati" per ogni altre classe. Ad esempio, se in un progetto si ricorre spesso alla creazione di file XML, si potrebbe fare riferimento al metodo "generalizzato", dichiarato in una interfaccia, col nome di "CreateXML()".

L'esempio che viene proposto cerca di non rifarsi a casi reali ma semplicemente, mette in evidenza la sintassi generale, sull'utilizzo delle interfacce:

File: interfacce.php (1° parte - Definizione di due interfacce)

Codice PHP:

<?php
interface prima_interfaccia{
    
    function primo_metodo();
    
    function secondo_metodo();
    
}

interface seconda_interfaccia{
    
    function terzo_metodo();
    
    function quarto_metodo();
    
}

...

File: interfacce.php (2° parte - Implemetazione delle due interfacce in una classe)

Codice PHP:

...

class miaClasse implements prima_interfaccia, seconda_interfaccia{
    
    function primo_metodo(){
        echo("Operazioni del primo metodo<br />");
    }
    
    function secondo_metodo(){
        echo("Operazioni del secondo metodo<br />");
    }
    
    function terzo_metodo(){
        echo("Operazioni del terzo metodo<br />");
    }
    
    function quarto_metodo(){
        echo("Operazioni del quarto metodo<br />");
    }
    
}

.. 


File: interfacce.php (3° parte - Test della classe)

Codice PHP:

...

//Test della classe: miaClasse
$mioOggetto = new miaClasse;
$mioOggetto->secondo_metodo();
$mioOggetto->quarto_metodo();
?> 


Conclusioni

Questo primo articolo ha cercato di fornire una panoramica generale sulla programmazione orientata agli oggetti nel contesto del web, mediante il linguaggio PHP, ma non ha evidenziato altre caratteristiche importanti, rivolte soprattutto a tecniche OOP avanzate, che, in pochi casi vengono utilizzate, come ad esempio le classi di tipo Final, i modificatori di tipo Static, il concetto di SingleTon, tecniche Factory, la serializzazione e la persistenza di oggetti nel tempo, le tecniche di introspezione, il Type Hinting, simulazione di overloading, attributi e metodi statici ed altro ancora. Tutto questo, lo si cerchera' di approfondire in seguito, attraverso un ulteriore articolo improntato su altre tecniche per la OOP.
Sebbene il PHP 5.0 abbia fornito grosse novita' nell'ambito della programmazione orientata agli oggetti e dei passi fatti in questo campo, non possiamo ancora affermare che questo linguaggio sia completamente OOP, si consideri Java o C++, anche se, gli stessi sviluppatori del PHP 5.0 stanno gia' lavorando su PHP 6.0.
Ovviamente la programmazione web, anche se stretta *parente* della programmazione software, al momento non potra' fornire in modo concreto tutti i vantaggi della OOP, in quanto il contesto e' molto diverso, si dia uno sguardo al funzionamento dei Server Web ed alle tecniche per la persistenza dei dati e dell'evoluzione degli oggetti nel tempo, un concetto nuovo e macchinoso rispetto alla OOP offerta da linguaggi di programmazione come il C++ o Java.
Sviluppare applicazioni OO non e' semplice, molto del successo dipende dall'esperienza maturata nel tempo e da tante prove pratiche del programmatore stesso, a volte potrebbe rivelarsi piu' complicato che sviluppare applicazioni per via procedurale. Il tutto e' dovuto al contesto dell'applicazione da progettare e da tanti altri fattori. Solitamente si ricorre alla OO per il web, nello sviluppo di classi generiche di utilita', per la gestione di files, database, autenticazioni utente, generazione di grafici, transazioni bancarie, manipolazione di dati, gestione della Cache e tanto altro, tutto il necessario per ovviare alla ripetizione di codice "inutile". La programmazione orientata agli oggetti viene maggiormente apprezzata in ambito Java o C++, poiche' e' possibile far interagire meglio, piu' oggetti dello stesso tipo e osservarne l'evoluzione in tempo reale. L'utilizzo lato web della OOP e' leggermente sacrificato, ma in molti casi si rivela un ottimo strumento di sviluppo per le nostre funzioni di utilita'. Ci resta da aspettare dunque, ulteriori aggiornamenti in materia e nuovi articoli tecnici... E magari, anche una nuova concezione di Web Server.

Per il momento e' tutto,
*Happy programming*,
Giuseppe Leone

Riferimenti:
- PHP & MySQL: la guida (McGraw-Hill)
- PHP.net
- PHP 4 e la programmazione orientata agli oggetti
- PHP 4: OOP, web form e inserimento dati in DB

"Dedicato al mio caro gatto Minu'..."

[Webtek]

Ottima panoramica sulla programmazione orientata agli oggetti,
i migliori complimenti
Franco.