PHP e OOP: Traits e Namespace

Articoli precedenti sullo stesso tema OOP in PHP nei portali umbriaway:

https://umbriawayinfo.wordpress.com/2019/04/07/programmazione-procedurale-oppure-oop-this-is-the-problem/

https://umbriawaypotenzia.wordpress.com/2019/04/07/php-versione-sette-introdotte-nuove-direttive-per-trasformare-il-linguaggio-in-fortemente-tipicizzato/

https://umbriawaysemplifica.wordpress.com/2019/04/08/ambito-di-visibilita-delle-variabili-in-php-public-protected-private/

https://umbriawaytarget.wordpress.com/2019/04/08/php-oop-magic-method-e-costruttori/

https://umbriawayvalorizza.wordpress.com/2019/04/08/warning-ambito-di-visibilita-publica-delle-classi-encapsulation-e-sicurezza-metodi-getter-e-setter/

https://umbriawayvendita.wordpress.com/2019/04/09/php-e-oop-magic-method-__autoload-ereditarieta-pianificazione-iniziale-con-uml/

https://umbriawaynoir.wordpress.com/2019/04/09/php-e-oop-overriding-e-polimorfismo/

https://umbriawayformazione.wordpress.com/2019/04/09/php-e-oop-membri-statici-e-costanti-all-interno-di-una-classe/

https://umbriawayfocus.wordpress.com/2019/04/09/php-e-oop-classi-astratte/

https://umbriawayfidelizza.wordpress.com/2019/04/09/php-e-oop-le-interfacce/

Il problema delle interfacce è che i metodi sono appena definiti ma non sono implementati, questo è un problema per l’ereditarietà che alla fine si ritrova in casa delle funzioni che vanno rese corporee e l’estensione di una interfaccia diventa una operazione senza costrutto. Per aggirare questo problema nella programmazione a oggeti in PHP esiste una risorsa denominata TREAT. Una estensione della classe in PHP posso ereditare solo da una classe padre e sulle interfacce l’ereditarietà dei metodi non implementa in metodi ma solo le regole formali del modello. Con il Traits io posso iniettare dei metodi all’ interno della classe figlio, una novità introdotta dalle versioni 5.4 di PHP. Il TRAITS è come l’interfaccia, non mi permette di usare i metodi se non usando la parola chiave USE. All’interno del TRATS io posso rendere disponibile N Metodi sostanzialmente alla classe erditando tutto quello che serve a livello di funzionalità aggirando i problemi di una cattiva implementazione delle classi.

Vediamo un esempio:

/*

<?php
trait Miodebug {
public function debug($dato1,$dato2) {
echo ‘Debug Riga ‘ . $dato1 . ‘->’ . $dato2;
}
}

file index.php di output:

<?php
require_once “classi\Prodotto.php”;
require_once “classi\Libro.php”;

$nlibro = new Libro(‘Sandokan’, ‘Salgari’, ‘1234ASB’);
$nlibro->setQta(5);
echo $nlibro->debug(‘7’,$nlibro->getQta());
$nlibro->addQta(10);
echo $nlibro->debug(‘9’,$nlibro->getQta());

*/

potrei partire da qui per creare con il polimorfismo un nuovo file che include anche il mio TREATS ossia dicendo per esempio:

class Libro extends Prodotto {
USE Miodebug;

se volessi implementare l’uso dei metodi Miodebug all’ interno della nuova classe, senza dimenticarmi che devo includere il path di collegamento su require_once require_once “classi\Miodebug.php”;

A questo punto non ci resta che parlare dei namespace. Il concetto di namespace è stato introdotto a partire dalla versione 5.3 scopiazzando l’idea di Java. Per organizzare meglio i metodi della classe i namespace risolvono, se avessi più metodi uguali con lo stesso nome il tutto genererebbero confusione. Namespace è sinonimo di cartelle. Abbiamo uno spazio dei nomi globali. Ma nulla mi impedisce di diversificare la mia organizzazione creando uno spazio di nomi tipo

com. farwebdesign

sotto dei quali posso inserire altri cassetti o sottocategorie per contenere le classi, raggruppate per organizzazione logica modello albero. Il namespace si definisce come prima riga del file e viene applicato a ogni interfaccia, classe o costante incluso nel file, esempio di sintassi:

namespace networking;

per esempio. In questo modo ci svincoliamo dallo spazio dei nomi generico ed entriamo specificatamente all’ interno della cartella networking. Però una classe presente all’ interno di un namespace specifico non puà essere richiamata in modo tradizionale come accadeva istanziando con la parola chiave NEW quindi come aggira il problema PHP?

Vediamo un esempio pratico:

/*
<?php
namespace tracking;
class Hits {
protected $ip;
protected static $numhits = 0;
public static function increment() {
self::$numhits++;
}
public function totalHits() {
return self::$numhits;
}
public function setIp() {
$this->ip = $_SERVER[‘REMOTE_ADDR’] ;
$this->saveIp($this->ip);
}
public function saveIp($ip) {
echo “IP Salvato ” . $ip;
}
}

prima soluzione sul file index.php:

<?php
require_once “tracking\Hits.php”;
$nh = new tracking\Hits();
$nh->setIp();

o la seconda soluzione su index1.php introdotta dalla versione sette, che alleggerisce il carico dei file sui namespace che utilizza la parola chiave USE:

<?php
use tracking\Hits;
require_once “tracking\Hits.php”;
$nh = new Hits();
$nh->setIp();

*/

Annunci

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione /  Modifica )

Google photo

Stai commentando usando il tuo account Google. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )

Connessione a %s...