• seguici su feed rss
  • seguici su twitter
  • seguici su linkedin
  • seguici su facebook
  • cerca

SEI GIA' REGISTRATO? EFFETTUA ADESSO IL LOGIN.



ricordami per 365 giorni

HAI DIMENTICATO LA PASSWORD? CLICCA QUI

NON SEI ANCORA REGISTRATO ? CLICCA QUI E REGISTRATI !

Le classi in PHP. introduzione alla programmazione in stile OOP, metodi e proprietà di una classe.

di :: 26 ottobre 2020
Le classi in PHP. introduzione alla programmazione in stile OOP, metodi e proprietà di una classe.

A partire dalla versione 5, PHP, dopo essere stato solo un linguaggio procedurale, si è affacciato alla programmazione ad oggetti, introducendo le classi.

E' una significativa evoluzione di PHP, ed oggi possiamo tranquillamente paragonarlo ad altri più affermati linguaggi che lavorano ad oggetti come ad esempio JAVA, anche se PHP è per sua natura solo "web oriented" e quindi presenta limiti sia nell’architettura che nella sintassi. Per questo motivo spesso si parla di "programmazione in stile OOP" e non proprio di "Programmazione Orientata agli Oggetti".

Alla base di questa "Programmazione Orientata agli Oggetti" vi sono le classi.

Nel PHP procedurale siamo abituati a lavorare solo con le funzioni, ed all'interno delle funzioni eseguiamo una serie di operazioni.

In estrema sintesi possiamo dire, a chi non sa cosa siano le classi, e me ne vogliamo i programmatori skillati, che le classi sono dei contenitori, al cui interno ci sono variabili e funzioni. Non andrò più a chiamare direttamente una funzione, bensi chiamerò inizialmente la classe, ed in termine tecnico si dice cha vado a "istanziare un oggetto di quella classe", e grazie a questa istanza posso poi accedere alle variabili e alle funzioni contenute dentro la classe. Quindi c'è uno step in più rispetto all'utilizzo classico delle funzioni: la creazione di un oggetto di quella classe. Creato l'oggetto posso utilizzare la funzione in essa contenuta.

Inoltre all'interno di una classe:

  • le variabili si chiamano proprietà
  • le funzioni si chiamano metodi

Voi potrete pensare che questa sia una complicazione. Potrei forse essere d'accordo con voi per progetti di piccola entità o se lavorate da soli. Ma se avete a che fare con progetti elaborati ed al progetto collaborano più persone, questo tipo di approccio risulterà senza dubbio migliore per l'organizzazione del codice, per il suo riutilizzo, per la possibilità di lavorare assieme ad altri programmatori su blocchi di codici separati, e per tutta una serie di ragioni che scoprirete da soli utilizzandolo.

Struttura di una classe

Per definire una classe nel nostro script PHP utilizziamo la parola chiave "class" seguita da un nome a nostra scelta, e non deve contenere spazi.

Per convenzione si utilizza la prima lettera maiuscola, e nel caso questo nome contenga più parole, in maiuscolo la prima lettera di ogni parola.

Dopo avere indicato il nome della classe, all'interno di parentesi graffe inseriremo le proprietà e i metodi della classe stessa.

Ecco un esempio molto semplice in cui inseriamo un metodo (una funzione) all'interno della classe "MioTest"

<?php 
class MioTest
{
    public function saluto(){
       echo "ciao";
    }
}
?>

Per adesso non badate a quel "public" messo prima del metodo (funzione), ce ne occuperemo tra poco.

Come si utilizza questa classe?

La prima cosa da fare è "creare un oggetto di classe MioTest" (una istanza della classe), in pratica creo una sorta di connettore a questa classe che poi mi consentirà di chiamare la funzione che è al suo interno.

Per fare questo si utilizza la parola chiave "new" seguita dal nome della classe

$obj = new MioTest;​

Creato l'oggetto $obj posso finalmente accedere alla funzione "saluto" contenuta al suo interno, utilizzando una freccia seguita dal nome della funzione

$obj -> saluto();

Mettiamo tutto assieme nel seguente codice

<?php 
class MioTest
{
    public function saluto(){
       echo "ciao";
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest;
// accedo alla funzione "saluto"
$obj -> saluto();
?>

Lanciate lo script e l'output sarà

ciao

Avete creato la vostra prima classe!

Abbiamo parlato anche di proprietà, cioè delle variabili contenute all'interno di questo microcosmo chiamato classe.

Ampliamo il nostro esempio, inserendo una proprietà (variabile) chiamata "nome" all'interno della classe "MioTest".

<?php 
class MioTest
{
    // proprietà, cioè una variabile
    public $nome="pippo";

    // metodo, cioè una funzione
    public function saluto(){
       echo "ciao da ".$this->nome;
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest;
// accedo alla funzione "saluto"
$obj -> saluto();
?>

Anche in questo caso, per adesso non badate al public presente prima della proprietà.

All'interno nel metodo "saluto" abbiamo utilizzato la proprietò "nome" utilizzando una freccia

$this->nome;

in modo simile a "$obj -> saluto", ma in questo caso siamo dentro la classe e qui dentro si utilzza "$this".

Questo, detto in parole molto semplici.

Visibilità di metodi e proprietà

Abbiamo visto negli esempi precedenti quel "public" anteposto al nome del metodo e della proprietà.

Questa è la visibilità del metodo e della proprietà, e descrive la possibilità di accedere, a questo metodo o proprietà, dall'esterno della classe, e dall'interno.

La visibilità può essere:

  • public: significa che sono accessibili anche da fuori della classe
  • protected: accessibili sono dall'interno della classe
  • private: accessibili sono dall'interno della classe, ma non nelle classi CHILD

Cerchiamo di capire questo concetto ripartendo dall'esempio precedente.

Visilbilità PUBLIC di metodi e proprietà

Il metodo "saluto" ha visibilità public, per cui posso accedere al metodo dall'esterno della classe, ed è quello che abbiamo fatto quando, dopo aver creare l'oggetto di classe "MioTest" abbiamo chiamato il metodo "saluto" così

$obj -> saluto();

Se quel metodo fosse stato "private" o "protected", non avremmo potuto farlo. A titolo di esempio prova a impostare come "private" quel metodo, e rilancia lo script. Il risultato sarà il seguente:

Fatal error: Uncaught Error: Call to private method MioTest::saluto() ....

Rimettete il metodo come pubblico e soffermiamo adesso sulle proprietà (le variabili).

Se la proprietà ha visibilità pubblica, posso utilizzarla dentro e fuori la classe. Dentro, abbiamo già visto come. Fuori lo vediamo adesso e lo facciamo in modo analogo a quando fatto per accedere al metodo, con la freccia:

<?php 
class MioTest
{
    // proprietà, cioè una variabile
    public $nome="pippo";

    // metodo, cioè una funzione
    public function saluto(){
       echo "ciao da ".$this->nome;
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest;
// accedo alla funzione "saluto"
$obj -> saluto();
echo "<br>"
// accedo alla proprietà pubblica $nome
$obj -> nome;
?>

L'ouput sarà

ciao da pippo
pippo

Non solo posso utilizzarlo da fuori, ma possiamo anche modificarlo, assegnandogli un valore diverso, in questo modo

<?php 
class MioTest
{
    // proprietà, cioè una variabile
    public $nome="pippo";

    // metodo, cioè una funzione
    public function saluto(){
       echo "ciao da ".$this->nome;
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest;
// assegno alla proprietà "nome" il valore "pluto"
$obj -> nome="pluto";
// accedo alla funzione "saluto"
$obj -> saluto();
?>

L'output sarà

ciao da pluto

Se la proprietà fosse private o protected, non potrei ne accedere ne modificare la proprietà dall'esterno della classe.

Visilbilità PROTECTED di metodi e proprietà

Come abbiamo già detto, una visibilità private consente di usare metodi e proprietà solo all'interno della classe.

Modifichiamo il nostro esempio così, assegnando visibilità private alla proprietà "nome". Possiamo tranquillamente continuare ad utilizzarlo nella classe, ma non da fuori.

<?php 
class MioTest
{
    // proprietà, cioè una variabile
    private $nome="pippo";

    // metodo, cioè una funzione
    public function saluto(){
       echo "ciao da ".$this->nome;
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest;
// accedo alla funzione "saluto"
$obj -> saluto();
?>

Visilbilità PRIVATE di metodi e proprietà

Simili ai precedenti, MA non sono accessibili dalle classi "child", ma per spiegare cosa sono le classi "child" dobbiamo introdurre il concetto di ereditarietà delle classi, e lo facciamo subito

Ereditarietà delle classi

Una classe detta "figlia" o "child" può ereditare proprietà e metodi di un'altra classe "padre" o "parent".

Capiamo subito questo concetto con un esempio. Abbiamo una classe A con dentro tre prorietà (public, private e protected) e tre metodi (public, private e protected) così possiamo vedere in azione tutte le possibilità visibilità

class A {
    // proprietà
    public $isPropPub=1;
    private $isPropPriv=2;
    protected $isPropProt=3;

    // metodi
    public function isMetPub(){
        echo "Metodo".__METHOD."<br />";
    }
    public function isMetPriv(){
        echo "Metodo".__METHOD."<br />";
    }
    public function isMetProt(){
        echo "Metodo".__METHOD."<br />";
    }
}

Abbiamo poi una seconda classe chiamata "B" che estende la classe "A", utilizzando la parola chiave "extend": è come se fosse un'appendice: al suo interno avrà i suoi metodi e proprietà, ma, estendendo la classe "A" potrà utilizzare (cioè eredita) anche i metodi e proprietà di questa. La classe "B" è la classe "child", la classe "A" è la classe parent.

Nella classe B posso accedere alle proprietà e metodi della classe padre A... ma non a tutti, solo a quelli "public" e a quelli "protected", non a quelli "private" perchè, per quando abbiamo detto prima, sono accessibili solo dall'interno della classe padre A. In questo esempio, nella classe B, ho un metodo pubblico "test" al cui interno accedo alla proprietà "isPropPub" della classe A.

class B extends A {
	public function test() {
	       echo "Ciao dalla classe B: il valore della proprieta isPropPub è ".$this->isPropPub."<br />";
	}
}

In modo analogo avrei potuto accedere alla proprietà "isPropProt" che è protected, e ai metodi pubblici e protetti "isMetPriv()" e "isMetProt()".

Mettiamo assieme tutto il codice, e creiamo un oggetto di classe A ed accediamo come già sappiamo al suo metodo pubblico "isMetPub()". Poi creiamo un oggetto di classe B, e accediamo al suo metodo pubblico "test". Questo, a sua volta, come vediamo lanciando lo script, può accedere ai metodi e proprietà della classe A, e nello spacifico accete alla proprietà "isPropPub"

<?php

class A {
    // proprietà
    public $isPropPub=1;
    private $isPropPriv=2;
    protected $isPropProt=3;

    // metodi
    public function isMetPub(){
        echo "Sto usando il metodo isMetPub della classe A<br />";
    }
    public function isMetPriv(){
        echo "Sto usando il metodo isMetPriv della classe A<br />";
    }
    public function isMetProt(){
        echo "Sto usando il metodo isMetProt della classe A<br />";
    }
}

class B extends A {
	public function test() {
	       echo "Sto usando la classe B, il valore della proprieta isPropPub è ".$this->isPropPub;
	}
}

// istanzio un oggetto di classe A
$obj = new A;
// accedo al metodo pubblico della classe A "isMetPub"
$obj -> isMetPub();

// istanzio un oggetto di classe B
$obj = new B;
// accedo al metodo test della classe B "test"
$obj -> test();
?>

Il risultato sarà questo

Sto usando il metodo isMetPub della classe A
Sto usando la classe B, il valore della proprieta isPropPub è 1

Lascio a voi fare delle prove di accesso ai vari metodi e proprietà, dall'interno e dall'esterno delle classi.

Esiste un limite all'ereditarietà: PHP non supporta l'ereditarietà multilpla, cioè una classe non può ereditare più classi

class B extends A,C {....}

Ma è possibile superare questo limite con i TRAIT, argomento che tratteremo nei prossimi giorni.

Override dei metodi e final OOP

Fare un override di un metodo signfica sovrascrivere all'interno della classe figlia un metodo definito all'interno della classe parent

Come esempio, definiamo una classe "F" con dentro un metodo public "test"

class F {
  public function test()
  {
      echo "ciao dalla classe ".__CLASS__;
   }
}

Definiamo anche una classe G che estende la classe "F", con dentro un metodo public con lo stesso nome "test"

class G extends F {
   public function test()
   {
      echo " e qui siamo nella classe ".__CLASS__;
   }
}

Istanziamo uno oggetto della classe figlia "G", e chiamiamo il metodo test

$obj=new G;
$obj->test();

Mettiamo tutto assieme in uno script

<?php

class F {
  public function test()
  {
      echo "ciao dalla classe ".__CLASS__;
   }
}

class G extends F {
   public function test()
   {
      echo " e qui siamo nella classe ".__CLASS__;
   }
}

$obj=new G;
$obj->test();
?>

Lanciamo lo script e verrà richiamato il metodo "test" del CHILD e non del PARENT.

Ma attenzione: il metodo della classe CHILD deve avere visibilità uguale o superiore a quella del PARENT !

L'ordine di importanza di visibilità è il seguente, da quella superiore a quella inferiore:

  1. PUBLIC
  2. PROTECTED
  3. PRIVATE

Per cui:

  • se la classe CHILD avesse un metodo PROTECTED, lo script andrebbe in errore perchè il metodo del PARENT avrebbe visibilità maggiore (PUBLIC) rispoetto alla visibiltià del CHILD (PROTECTED)
  • se nella classe PARENT il metodo fosse stato PROTECTED, la classe CHILD poteva avere un metodo PUBLIC o PROTECTED

C'è anche modo che una classe non venga mai estesa. Per fare questo indichiamo la classe come "final".

final class F {
  public function test()
  {
      echo "ciao dalla classe ".__CLASS__;
   }
}

Prova a modificare con "finale" il tuo script e rilancialo, vedrai questo errore

Fatal error: Class G may not inherit from final class (F) in /var/www/html/test/index.php on line 15

Questo perchè la class "G" estende la "F" ma la classe F non si può estendere !

E' possibile impostare come "finale" una classe, come abbiamo visto, o un metodo.

Se impostiamo come "final" il metodo, la classe potrà essere estesa, è solo il metodo che non potrà essere sovrascritto
Se impostiamo come "final" la classe è tutta la classe a non poter essere estesa.

Il metodo costruttore

Questo metodo è un "metodo magico" cioè viene automaticamente chiamato non appena istanzio la classe che lo contiene, ed ha come nome "__construct".

Vediamo subito in azione. In questo script ho la classe "MioTest" con dentro il metodo costruttore che risponderà con un "ciao".

<?php 
class MioTest
{
    // metodo costruttore
    public function __construct(){
       echo "ciao";
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest;
?>

Istanzio un oggetto di classe "MioTest" e non faccio altro. Se provate a lanciare lo script vedrete come output "ciao". Questo significa che il metodo costruttore è stato chiamato automaticamente, senza doverlo chiamare manualmente.

Un metodo costruttore è utile per eseguire delle operazioni preliminari all'interno della classe, ma anche, e sopratutto, per poter consentire alla classe di ricevere parametri, come normalmente facciamo nelle funzioni.

Ad esempio, se voglio che la classe riceva i parametri "cognome" e "nome", e procedo come in questo script, che analizziamo subito.

<?php 
class MioTest
{
    // metodo costruttore
    public function __construct($x,$y){
       echo "ciao da ".$x." ".$y;
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest("Rossi","Paolo");
?>

Nel metodo costruttore, riceverò i due parametri dall'esterno della classe, cioè quando vado a creare un oggetto della classe "MioTest", e li chiamo x e y.

Per utilizzare i due parametri sarà sufficente effettuare un "echo" di $x e $y. Ecco il risultato:

ciao da Rossi Paolo

Ne approfitto per dirti che, se non fosse ancora chiaro, puoi istanziare quanti oggetti vuoi di una classe, ed ognuno avrà la sua vita indipendente dagli altri oggetti.

Potrei quindi tranquillamente istanziare tre oggetti

$obj= new MioTest("Rossi","Paolo");
$obj= new MioTest("Bianchi","Mario");
$obj= new MioTest("Verdi","Lucia");

Bene, adesso torniamo all'esempio precedente e facciamoci del male, rendiamo più articolato, anche se il risultato sarà il medesimo.

<?php 
class MioTest
{
    private $cognome;
    private $nome;

    // metodo costruttore
    public function __construct($x,$y){
       $this->cognome=$x;
       $this->nome=$y;
       echo "ciao da ".$this->cognome." ".$this->nome;
    }
}

// creo un oggetto di classe "MioTest"
$obj= new MioTest("Rossi","Paolo");
?>

In questo script ho operato così

  • ho definito due proprietà chiamate "nome" e "cognome" con visibilità private (potevo anche indicarla come protected o public, tanto li uso solo all'interno di questa classe)
  • nel metodo costruttore, ricevo i due parametri x e y, come nell'esempio precedente.
  • all'interno del metodo costruttore ho assegnato i due valori ricevuti, "x" e "y", alle due proprietà "cognome" e nome"
  • infine ho effettuato un echo delle due proprietà

Proprietà e metodi STATICI

Sono elementi non accessibili tramite l'oggetto cioè tramite una istanza della classe, bensì sono elementi interni alla classe stessa.

Ad esempio, creiamo una classe con due proprietà, una public "anni" che rendiamo anche "statica", una protected "nome", ed un metodo "getName" public che restituirà il valore della proprietà "nome".

Istanziamo quindi un oggetto della classe H e proviamo ad accedere alla proprietà "anni" come faremmo normalmente.

<?php

class H{
	protected $nome="Giulio";
	public static $anni="14";

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

$obj=new H;
echo $obj->anni;
?>

Questo script non renderà nulla perchè, per accedere alle proprietà statiche, non possiamo avvalerci dell'oggetto "$obj->anni", ma dobbiamo usare questa sintassi "H::$anni".

Correggiamo quindi lo script

<?php

class H{
	protected $nome="Giulio";
	public static $anni="14";

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

$obj=new H;
echo H::$anni;
?>

Adesso questo script resituirà il numero 14.

Adesso rendiamo statica anche l'altra proprietà "nome", che è utilizzata nel metodo getName.

Quindi istanziamo un oggetto di classe H e poi accediamo al metodo "getName"

<?php

class H{
	protected static $nome="Giulio";
	public static $anni="14";

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

$obj=new H;
echo $obj->getName();

?>

Anche in questo caso non avremo una risposta dal metodo, perchè per utilizzare una proprietà statica, dentro al metodo, deve usare una sintassi differente che utilizza la parola chiave "self"

<?php

class H{
	protected static $nome="Giulio";
	public static $anni="14";

	public function getName()
	{
		return self::$nome;
	}
}

$obj=new H;
echo $obj->getName();

?>

Il metodo restituirà "Giulio".

Complichiamoci la vita, creando una classe CHILD (figlia): per accedere da questa classe, ad una proprietà o metodo statico della classe parent dobbiamo utilizzare la parola chiave "parent"

<?php

class H{
	protected static $nome="Giulio";
	public static $anni="14";

	public function getName()
	{
		return self::$nome;
	}
}

class I extends H{
	public function test()
	{
		return parent::$nome;
	}
}

$obj=new I;
echo $obj->nome;
?>

Abbiamo istanziato un oggetto della classe "I" e successivamente abbiamo avuto accesso alla proprietà "nome".

Per i metodi vale la stessa cosa, ad esempio dichiariamo statico il metodo "test".

<?php

class H{
	protected static $nome="Giulio";
	public static $anni="14";

	public function getName()
	{
		return self::$nome;
	}
}

class I extends H{
	public static function test()
	{
		return parent::$nome;
	}
}

$obj=new I;
echo I::test();
?>

Per accedere al metodo, adesso statico, "test", abbiamo utilizzare la sintassi "I::test()".

Un paio di note finali.

La prima: questi "::" (due punti) vengono chiamati SCOPE RESOLUTION OPERATOR.

La seconda: esiste un'altra sintassi che prevede la definizione di una variabile che ha, come valore, in nome della classe stessa.

Ad esempio setto la variabile "x" con il valore "I" della classe, e poi utilizzo la variabile al posto del nome della classe, così

$x="I";
$x::test();

Questo può essere utile se nello script richiamiamo molte volte la stessa classe  e se la classe avesse un nome lungo. In questo modo semplifichiamo il codice.

Classi astratte

Una classe astratta è un particolare tipo di classe che 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 questa tipologia di classe come una "base di partenza" o un "modello" per la creazione di classi figlie.

Inoltre all'interno di una classe astratta è possibile definire uno o più metodi astratti. La differenza tra un metodo normale e un metodo astratto è che il metodo astratto non viene "implementato" cioè non si inserisce nessun codice all’interno del metodo, a da questo deriva la definizione di "metodo senza corpo". Questo metodo astratto però dovrà essere implementato dalla classe figlia, con lo stesso nome e stessi eventuali argomenti.

All'interno della classe astratta ci possono essere anche metodi non astratti, oltre a quello astratto.

Capiamo questi concetti con un esempio.

Abbiamo una classe astratta "L" che contiene un metodo pubblico normale "getName", ed un metodo astratto "schedaUser" che, come vediamo, non ha codice al suo interno.

Proviamo ad istanziare questa classe astratta.

<?php

abstract class L {
	public abstract function schedaUser(int $idUser);

	public function getName()
	{
		echo "giulio";
	}
}

$obj=new L;
?>

La classe astratta "L" non puo essere istanziata e l'errore visualizzato sarà il seguente

Fatal error: Uncaught Error: Cannot instantiate abstract class L in /var/www/hml/test/index.php:12

All'interno della classe astratta, come sappiamo, possiamo implementare dei metodi che sono ereditati dalle classi figlie, e che possono o meno essere utilizzati dalle classi figlie, come la "getName".

Ma se creiamo un metodo astratto, questo dovrà essere per forza utilizzato dalla classe figlia, come nel nostro esempio il metodo "schedaUser".

Estendiamo l'esemio percedente ed aggiungiamo la classe figlia "M" che estende la classe "L": all'interno della classe figlia devo utilizzare il metodo "schedaUser".

Istanzio quindi un oggetto di classe "M" ed accedo al metodo "schedaUser".

<?php

abstract class L {
	public abstract function schedaUser($idUser);

	public function getName()
	{
		echo "giulio";
	}
}

class M extends L {

	public function schedaUser($idUser)
	{
 		echo "elisa";
	}
}

$obj=new M;
M->schedaUser(12);
?>

Lanciamo lo script ed il risultato sarà "elisa".

Attenzione: la visilità del metodo "schedaUser" della classe CHILD deve essere maggiore o uguale alla visibilità del metodo astratto della classe PARENT, per cui, nel nostro esempio, non possiamo impostare, metodo "schedaUser" della classe CHILD, una visibilità protected o private, perchè sono visibilità inferiori rispetto a public.

Le interfacce

Le interfacce elencano tutti i metodi che le classi che le utilizzano devono implementare. Sono identificate dalla parola chiave "interface".

Questa interfaccia, che chiamo "iPippo", contiene 3 metodi pubblici. Questi metodi vengono solo elencati, non implementati nell'interfaccia.

interface iTemplate {
  public function getBody();
  public function getHeader();
  public function getFooter();
}

Creo quindi la classe "TemplateBaseHtml4" che implementa l'interfaccia "iTemplate": dovrà contenere per forza i tre metodi dell'interfaccia, in assenza andrebbe in errore

class TemplateBaseHtml4 implements iTemplate {
	public function getBody(){
		echo "<div>Body HTML 4</div>";
	}
	public function getHeader(){
		echo "<div>Header HTML 4</div>";
	}
	public function getFooter(){
		echo "<div>Footer HTML 4</div>";
	}
}

Una classe che implementa una interfaccia è come se dicesse "guarda che tu puoi interfacciarti con me con questi metodi". Io implemento quindi tutti i metodi definiti in quella interfaccia

Creo quindi un'altra classe "TemplateBaseHtml5" che implementa la stessa interfaccia "iTemplate"

class TemplateBaseHtml5 implements iTemplate {
	public function getBody(){
		echo "<div>Body HTML 5</div>";
	}
	public function getHeader(){
		echo "<div>Header HTML 5</div>";
	}
	public function getFooter(){
		echo "<div>Footer HTML 5</div>";
	}
}

Mettiamo tutto il codice in uno script, ed istanziamo un oggetto di classe TemplateBaseHtml4 ed un oggetto di classeTemplateBaseHtml5

<?php

interface iTemplate {
  public function getBody();
  public function getHeader();
  public function getFooter();
}

class TemplateBaseHtml4 implements iTemplate {
	public function getBody(){
		echo "<div>Body HTML 4</div>";
	}
	public function getHeader(){
		echo "<div>Header HTML 4</div>";
	}
	public function getFooter(){
		echo "<div>Footer HTML 4</div>";
	}
}

class TemplateBaseHtml5 implements iTemplate {
	public function getBody(){
		echo "<div>Body HTML 5</div>";
	}
	public function getHeader(){
		echo "<div>Header HTML 5</div>";
	}
	public function getFooter(){
		echo "<div>Footer HTML 5</div>";
	}
}

$obj1=new TemplateBaseHtml4;
$obj1->getHeader();
$obj1->getHeader();
$obj1->getFooter();

$obj2=new TemplateBaseHtml5;
$obj2->getHeader();
$obj2->getHeader();
$obj2->getFooter();

?>

Le due classi implementano gli stessi metodi, ma che al loro interno differiscono perchè rendono valori diversi, per cui il risultato sarà

Header HTML 4
Header HTML 4
Footer HTML 4
Header HTML 5
Header HTML 5
Footer HTML 5

Creiamo adesso un'altra interfaccia "iOther"

interface iOther {
     public function getolocalizzazione();
}

Una classe può implementare più interfacce, basta elencarle dividendole con una virgola, come in questo esempio in cui ci interfacciamo anche con il metodo "geolocalizzazione"

<?php

interface iOther {
     public function geolocalizzazione();
}

interface iInterface {
     public function getBody();
     public function getHeader();
     public function getFooter();
}

class TemplateBaseHtml4 implements iInterface,iOther {
	public function getBody(){
		echo "<div>Body HTML 4</div>";
	}
	public function getHeader(){
		echo "<div>Header HTML 4</div>";
	}
	public function getFooter(){
		echo "<div>Footer HTML 4</div>";
	}
	public function geolocalizzazione(){
		echo "<div>localizzato</div>";
	}
}

$obj1=new TemplateBaseHtml4;
$obj1->getHeader();
$obj1->getHeader();
$obj1->getFooter();
$obj1->geolocalizzazione();

?>

Il risultato sarà il seguente

Header HTML 4
Header HTML 4
Footer HTML 4
localizzato

Le classi visto nell'esempio implementano delle interfacce, ma in realtà possono anche estendere un'altra classe.

Ad esempio definiamo questa classe:

class TemplateStandard{
	public function test(){
		echo "test";
	}
}

Per estendere la classe "TemplateBaseHtml4" scriveremo:

class TemplateBaseHtml4 extends TemplateStandard implements iInterface

Creiamo uno script così possiamo testarlo.

<?php

interface iInterface {
     public function getBody();
     public function getHeader();
     public function getFooter();
}

class TemplateStandard{
	public function test(){
		echo "test";
	}
}

class TemplateBaseHtml4 extends TemplateStandard implements iInterface {
	public function getBody(){
		echo "<div>Body HTML 4</div>";
	}
	public function getHeader(){
		echo "<div>Header HTML 4</div>";
	}
	public function getFooter(){
		echo "<div>Footer HTML 4</div>";
	}
}

$obj1=new TemplateBaseHtml4;
$obj1->test();
?>

La classe "TemplateBaseHtml4" avrà quindi accesso ai metodi della classe parent "TemplateStandard" e posso chiamare il metodo test.

Conclusioni

Abbiamo così terminato questo primo approccio alle classi e alla programmazione orientata agli oggetti in PHP.

Seguiranno altre "lezioni" in cui tratterò di altri aspetti collegati alle classi come i trait, i namespace, i metodi magici e molto altro.

Stay tuned!

 
pay per script

Hai bisogno di uno script PHP personalizzato, di una particolare configurazione su Linux, di una gestione dei tuoi server Linux, o di una consulenza per il tuo progetto?

 
 
 
x

ATTENZIONE