Sei STATIC? Allora dovresti fare ginnastica: OOP e PHP, perché i richiami alle variabili statiche offrono flessibilità alle applicazioni, settima puntata

Nelle ultime puntate di OOP e PHP come https://umbriawayincrementa.wordpress.com/2020/04/22/pubblico-o-privato-questo-non-e-un-film-sugli-enti-dislocati-sulla-penisola-ma-oop-e-php/   abbiamo esplorato il potenziale offerto dai progetti che presentano una visibilità delle variabili (o proprietà) pubbliche o private, dipende molto anche dalle caratteristiche del progetto. A questo punto c’è una nuova parola che entra in scena STATIC. Ma di che stiamo parlando? Supponiamo che nella nostra classe GM debba trovarmi nella necessità di creare un account utente per un sito che ospita un area riservata magari con dei servizi a pagamento. Sappiamo che le classi hanno la funzione di proporre una riutilizzabilità del codice per cui potrei usare la classe ACCOUNT anche in altri progetti, quindi inizierò ad avere una classe che ospiterà un paio di variabili canoniche del tipo username e password:

class Account
{
private $username;
private $password;

}

supponiamo che ogni volta che un oggetto si istanzi su questo oggetto io voglia tenere il conto delle nuove istanze istanziate (è un gioco di parole ma rende l’idea). Quanti nuovi oggetti sono stati creati su quella classe? Sappiamo che una classe è un qualcosa di unico nel suo genere e che non possiamo prendere come riferimento ogni oggetto per fare un conto centralizzato del numero che ci interessa, quindi per forza dovremmo introdurre all’ interno della classe una proprietà universale che ha un valore assoluto che mai verrà modificato. Quindi ci viene in aiuto il nostro STATIC, una parola chiave che fa proprio al caso nostro perchè conosciamo i limiti dei metodi private perché leggono solo i membri privati dove vengono definiti, mentre in questo caso la nostra esigenza è un altra, ci serve una variabile contatore che si incrementa ogni volta che una nuova istanza viene creata. per cui iniziamo a introdurre una nuova voce nella nostra classe, private static $count;

class Account
{
private $username;
private $password;
private static $count;
}

A questo punto ci serve un metodo che prende in ingresso l’oggetto istanziato e lo incrementa ogni volta che l’operazione di un nuovo oggetto creato si ripete, quindi siccome abbiamo anche visto quale è l’utilità di un costruttore, cioé quella di inizializzare in automatico delle operazioni al momento della creazione dell’ oggetto, ci inventiamo una funzione (o metodo) __construct (è il modo convenzionale di implementare un costruttore) che fa al caso nostro, inserendo anche un nuovo elemento quella della costante PREFIX (per convenzione si scrivono in maiuscolo) che farà da separatore prima del numero incrementato:

class Account
{
private $username;
private $password;
private static $count;

const PREFIX=”user_”;

function __construct($u, $p=”12345″)
{
$this->username=self::PREFIX.$u;
$this->password=$p;

self::$count++;
printf(“Creato $this->username: account n. %d <br>”, self::$count);
}
}

Che fa sostanzialmente questo costruttore? Accetta due parametri di ingresso, in cui nel secondo quello della password ($p) diciamo arbitrariamente che ha un valore universale se non viene inserito, in questo modo quando verrà creato l’ogetto io dovrò soltanto digitare $u, ossia lo username. Poi assegno i parametri degli argomenti inseriti tra parentesi a delle assegnazioni dell’ oggetto account, tenendo appunto presente che grazie alla costante prefisso avrò poi un separatore con il numero incrementale nel conteggio delle istanze create. Il tutto sembra più difficile da raccontare che a farsi in quanto una volta istanziati i nostri oggetti e ottenuto il nostro script, grazie a http://phptester.net/ a video otterremo:

class Account
{
private $username;
private $password;
private static $count;
const PREFIX=”user_”;

function __construct($u, $p=”12345″)
{
$this->username=self::PREFIX.$u;
$this->password=$p;

self::$count++;
printf(“Creato $this->username: account n. %d <br>”, self::$count);
}
}

$a=new Account(“Svidler”);
$b=new Account(“Aronian”);
$c=new Account(“Carlsen”);
$d=new Account(“Piscopo”);

RISULTATO A VIDEO e risposta alla domanda quanti oggetti sono stati istanziati:

Creato user_Svidler: account n. 1
Creato user_Aronian: account n. 2
Creato user_Carlsen: account n. 3
Creato user_Piscopo: account n. 4

Da notare infine il sibilinno simbolo arcano geroglifico o assiro babilonese %d che funziona solo da SEGNAPOSTO per lasciare spazio a self::$count ossia la nostra variabile statica. Se ne deduce quindi che i caratteri i due punti ripetuti sono proprio un modo caratteristico nella sintassi di PHP di riconoscere le proprietà statiche di una classe che sono per l’appunto dei valori assoluti presenti nella classe come riferimento per tutti gli oggetti che verranno istanziati

Programmazione procedurale oppure OOP? This is the problem!

La programmazione ad oggetti ha sempre suscitato vere e proprie guerre concettuali, tra sostenitori delle due fazioni. C’è chi sostiene che senza OOP non si potrebbero mettere in piedi dei progetti complessi. E c’è chi sostiene che la procedurale basta e avanza per spedire una mail con gli allegati. Senza la programmazione procedurale non si potrebbe imparare l’Object Oriented Programming che è solo un approccio diverso per fare cose diverse. OOP non è un modo migliore per programmazre, è solo un modo diverso, dipende dal tipo di progetto che si vuole mettere in piedi. OOP è una filosofia di programmazione. Per fare OOP devi astrarre le cose. Casa, auto, stufa sono oggetti concreti con cui familiarizziamo ogni giorno. Per andare sulla luna ci sono decine di fasi e sottofasi in sequenza come per fare una torta o un semplice caffè. OOP richiede tutta una pianificazione anticipata a tavolino, se dico sedia devo definire le proprietà dell’ oggetto come colore e numero di gambe e i metodi o funzioni o azioni da mettere in atto: spostare la sedia, rovesciare la sedia etc, in base alla manipolazione dei dati che intendiamo operare. La programmazione procedurale è istintuale, la OOP è un paradigma, prima mi devo interrogare su cosa devo fare, poi devo identificare gli oggetti e poi decidere come sono definiti e quali azioni devono effettuare. Solo quando ho tutto chiaro e ho pensato i blocchi utili e necessari potrò mettere in pratica il mio cidce. OOP è una pianificazione fatta in anticipo. I problemi si risolvono con la tastiera sulla procedurale, mentre in OOP basta all’ inizio solo penna e foglio di carta. Su OOP dire classe indica la definizione della classe, mentre l’istanza della classa p il vero e proprio ogetto. Le proprietà sono le variabili con dei valori e i metodi sono funzioni interne alla definizione della classe. La classe è la ricetta di un budino , dove avremo la lista degli ingredienti e la somma delle operazioni da affettuare per arrivare al prodotto reale. Ad esempio la classe clienti nel nostro diagramma UML avrà un nome, un cognome, un indirizzo, una mail, un numero di telefono e dei metodi come recupero indirizzo o mail o cambio anagrafica. Le ricette sono tutte diverse, così come sono diversi gli ingredienti e le funzionalità. Definire le proprietà e le funzionalità è il core di una definizione di una classe. Con OOP posso scomporre un problema in tanti piccoli problemi e posso riutilizzare il codice per le stesse funzionalità. La manutenzione del codice viene semplificata e anche il debug è meno complesso. A questo punto la domanda è: come viene definita una classe in PHP? Ad esempio se abbiamo un libro come dobbiamo astrarre tutte le problematiche annesse? Un libro ha delle proprietà come titolo, quantità a magazzino, codice isbn, autore, costo, numero di pagine, immagine di copertina e ha anche dei metodi come sfogliare le pagine, la condizione delle pagine etc. Idem per una classe AUTO dove ho le proprietà dell’ oggetto da istanziare come colore interno, colore esterno numero di ruote e metodi come messa in moto etc. Anche nelle operazioni di shopping cart avrò accesso ai sistemi di login e di registrazione dei dati, a un carrello che memorizza le operazioni sugli articoli, l’invio per i pagamenti e ciascuno di questi blocchi può essere scomposto in sottoblocco per individuare le responsabilità che ogni oggetto deve avere tipo il cliente spedisce i dati, il cliente registra i dati. Ad esempio l’oggetto ordine deve specificare i dettagli effettuati, l’oggetto di verifica di spedizione sarà a carico dell’ oggetto mail e così via. Bisogna quindi stabilire le proprietà e le funzionalità per ogni oggetto. L’oggetto LOGIN deve avere tutta una serie di caratteristiche, un tipo di codifica per oscurare le pwd, un sistema di verifica per vedere se quella mail esiste e molto altro. Occorre definire quinti tutte le possibilità che il nostro oggetto ha a sua disposizione. Quindi si parte dal nome della classe, si definiscono le prorietà e infine i metodi. La definizione della classe non è l’oggetto che va istanziato. L’oggetto cliente ha una sua anagrafica per esempio. La classe libro per esempio potrà avere questo suo elenco di proprietà che possono anche essere inizializzate ma senza la creazione dell’ oggetto sarebbero inutili, senza i metodi che le leggono e le scrivono. Con public e private definisco il livello di riservatezza delle variabili, si parla di accessibilità rispetto alla visibilità interna o esterna, con delle variabili che in caso di private saranno consumabili solo all’ interno della classe:

/*
<?php
class Libro {
public $titolo;
public $autore;
public $codiceisbn;
public $prezzo;
private $quantita;
}
*/

classe inserita all’interno di una cartella arbitraria che verrà linkata sulla pagina di visualizzazione in questo modo, da notare l’uso della parola chiave NEW che crea l’oggetto vero e proprio:

/*
<?php
require_once “Classi/Libro.php”;
$nlibro = new Libro();
//echo $nlibro;
$nlibro -> titolo = ‘Le tigri di Mompracem’;
var_dump($nlibro);
*/

Una volta che abbiamo la ricetta per realizzare la torta possiamo istanziare e accedere alle proprietà. SI crea quindi la definizione della classe e si istanzia per creare un oggetto reale con la parola chiave NEW. La sintassi é $oggetto=NEW nomeclasse(); che non ha ancora la definizione delle proprietà al suo interno. Per accedere alle proprietà della classe dall’ esterno posso puntare solo sulle variabili di tipo PUBLIC, come visto sopra, omettendo al simbolo del dollaro menzionando la variabile: $nlibro -> titolo = ‘Le tigri di Mompracem’; in questo modo vado a travasare il contenuto della variabile nel vaso corrispondente, perché le variabili sono zone di memoria che conservano i dati.

E se volessi inserire nella definizione della classe un metodo tipo leggoTitolo con visibilità pubblica quindi accessibile dall’ esterno? Dovrò inserire una funzione interna alla classe che mette in moto dei metodi o delle azioni che fanno delle cose, la sintassi sarà $oggetto -> metodo:

/*
<?php
class Libro {
public $titolo;
public $autore;
public $codiceisbn;
public $prezzo;
public $quantita;

public function leggoTitolo() {
// return $titolo;
return $this->titolo;
}

}
*/

A questo punto la spontanea domanda, che lo script risolve, come faccio ad accedere a una variabile interna di una classe, trova la sua risoluzione. Bisogna fare molta attenzione alla sintassi perché va introdotta un’ altra parola magica: THIS! Con this possiamo accedere alle variabili interne di una classe: return $this->titolo; e far riferimento alla proprietà dell’ oggetto corrente.

E sevolessi stampare a video titolo e autore dopo aver settato le proprietà grazie a this? Vediamo la definizione della classe e il suo file di lettura:

/*
<?php
class Libro {
public $titolo;
public $autore;
public $codiceisbn;
public $prezzo;
private $quantita;
public function leggoTitoloAutore() {
// return $titolo;
return $this->titolo . ‘-‘ . $this->autore;
}
}
*/

/*
<?php
require_once “classi/Libro.php”;

$nlibro = new Libro();
$nlibro->titolo = ‘Sandokan’; // con this posso dare un valore alla prorpietà
$nlibro->autore = ‘Salgari’;
echo $nlibro->leggoTitoloAutore();
*/

 

Il risultato finale sarà il seguente: https://www.farwebdesign.com/PHPOOP/5/