Concetto di programmazione orientata agli oggetti (OOP) in PHP con esempio

Cos'è l'OOP?

La programmazione orientata agli oggetti è un approccio allo sviluppo software che modella un'applicazione attorno a oggetti del mondo reale, come dipendenti, automobili e conti bancari. Una classe definisce le proprietà e i metodi di un oggetto del mondo reale. Un oggetto è un'istanza di una classe.

Le tre componenti fondamentali della programmazione orientata agli oggetti sono:

• Analisi orientata agli oggetti – funzionalità del sistema
• Progettazione orientata agli oggetti – architettura del sistema
• Programmazione orientata agli oggetti – implementazione dell'applicazione

Principi di programmazione orientata agli oggetti

I tre principi fondamentali della programmazione orientata agli oggetti sono:

• incapsulamento – questo riguarda il nascondere i dettagli di implementazione ed esporre solo i metodi. Gli scopi principali dell'incapsulamento sono:
  • Ridurre la complessità dello sviluppo del software: nascondendo i dettagli di implementazione ed esponendo solo le operazioni, l'utilizzo di una classe diventa semplice.
  • Proteggere lo stato interno di un oggetto: l'accesso alle variabili di classe avviene tramite metodi come get e set. Questo rende la classe flessibile e di facile manutenzione.
  • Consente di modificare l'implementazione interna della classe senza preoccuparsi di compromettere il codice che la utilizza.
• Eredità – questo riguarda la relazione tra classi. La relazione assume la forma di un genitore e un figlio. Il figlio utilizza i metodi definiti nella classe genitore. Lo scopo principale dell'ereditarietà è:
  • Riutilizzabilità: più elementi figli possono ereditare dallo stesso elemento padre. Questo è molto utile quando dobbiamo fornire funzionalità comuni come l'aggiunta, l'aggiornamento e l'eliminazione di dati dal database.
• Polimorfismo – questo riguarda l'avere un'unica interfaccia con molte implementazioni diverse. Lo scopo principale del polimorfismo è:
  • Per semplificare la manutenzione delle applicazioni e renderle più estendibili.

OOP Concepts nel PHP

PHP è un linguaggio di scripting orientato agli oggetti; supporta tutti i principi sopra menzionati. I principi sopra menzionati vengono realizzati tramite:

• incapsulamento – tramite l'uso dei metodi “get” e “set” e dei modificatori di accesso.
• Eredità – tramite l'uso della parola chiave extends
• Polimorfismo – tramite l'utilizzo della parola chiave implements

Ora che abbiamo le conoscenze di base dell'OOP e di come è supportato PHPVediamo ora alcuni esempi che mettono in pratica i principi sopra esposti.

Cos'è UML?

Il linguaggio di modellazione unificato (UML) è una tecnica utilizzata per progettare e documentare sistemi orientati agli oggetti.

UML produce diversi documenti, ma in questo articolo analizzeremo il diagramma delle classi, che è molto importante per la programmazione PHP orientata agli oggetti.

Esempio di diagramma di classi

Chiave del diagramma di classi

• Migliori scatola superiore contiene il nome della classe
• Migliori casella centrale contiene le variabili di classe
• Migliori scatola inferiore contiene i metodi della classe
• Migliori meno (-) il segno indica ambito privato
• Migliori più (+) il segno significa ambito pubblico
• Migliori cancelletto (#) il segno significa ambito protetto

Come creare una classe in PHP

La parola chiave class viene utilizzata per definire una classe in PHP. Di seguito sono riportate le regole per creare una classe in PHP.

• Il nome della classe dovrebbe iniziare con una lettera
• Il nome della classe non può essere una parola riservata PHP
• Il nome della classe non può contenere spazi

Supponiamo di voler creare una classe per rappresentare gli animali. Inizieremo identificando le caratteristiche comuni a tutti gli animali.

• Tutti gli animali appartengono a una famiglia, come ad esempio gli erbivori, i carnivori, ecc.
• Tutti gli animali mangiano cibo

Il diagramma sottostante mostra il diagramma delle classi per l'animale.

Ora procediamo con la codifica della nostra classe Animal.

<?php
class Animal
{
    private $family;
    private $food;
    public function __construct($family, $food)
    {
        $this->family = $family;
        $this->food = $food;
    }
    public function get_family()
    {
        return $this->family;
    }
    public function set_family($family)
    {
        $this->family = $family;
    }
    public function get_food()
    {
        return $this->food;
    }
    public function set_food($food)
    {
        $this->food = $food;
    }
}
?>

QUI,

• “private $family, $food” significa che le variabili non possono essere accedute direttamente dall’esterno della classe (incapsulamento).
• “public function __construct($family…)” è il metodo costruttore di PHP. Questa funzione viene chiamata ogni volta che viene creata un'istanza della classe. In questo caso, stiamo impostando la famiglia e il cibo.
• “public function get…()” è il metodo utilizzato per accedere al valore della famiglia o del cibo (incapsulamento)
• “public function set…()” è il metodo utilizzato per impostare il valore della famiglia o del cibo (incapsulamento)

Come implementare l'ereditarietà in PHP

Lavoreremo con una mucca e un leone. Sia la mucca che il leone ereditano dalla classe Animale.

Il diagramma delle classi riportato di seguito mostra le relazioni.

Si noti che la mucca eredita dalla classe Animal e definisce anche le proprie variabili e i propri metodi.

Ora procediamo con la codifica della classe Cow.

<?php
class Cow extends Animal
{
    private $owner;
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
    public function set_owner($owner)
    {
        $this->owner = $owner;
    }
    public function get_owner()
    {
        return $this->owner;
    }
}
?>

Ora procediamo con la codifica della classe Lion.

<?php
class Lion extends Animal
{
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
}
?>

QUI,

• “class … extends Animal” fa sì che le classi Cow e Lion utilizzino i metodi della classe Animal (ereditarietà).

Come creare un oggetto della classe

Le classi Animale, Mucca e Leone dovrebbero essere tutte nella stessa directory per semplicità.

Creiamo ora l'applicazione che utilizza le nostre classi.

Esempio di classe PHP

<?php
require 'Animal.php';
require 'Cow.php';
require 'Lion.php';
$cow = new Cow('Herbivore', 'Grass');
$lion = new Lion('Carnivore', 'Meat');
echo '<b>Cow Object</b> <br>';
echo 'The Cow belongs to the ' . $cow->get_family() . ' family and eats ' . $cow->get_food() . '<br><br>';
echo '<b>Lion Object</b> <br>';
echo 'The Lion belongs to the ' . $lion->get_family() . ' family and eats ' . $lion->get_food();
?>

Testare la nostra applicazione

Ora visualizziamo la nostra applicazione in un browser web.

Entrambi gli oggetti riutilizzano i metodi get_family e get_food ereditati dalla classe Animal, il che dimostra l'ereditarietà in azione.

Come implementare il polimorfismo in PHP

Supponiamo di voler sviluppare un'applicazione che si connetta a diversi motori di database come MySQL and SQL Server ma utilizza la stessa interfaccia uniforme. Possiamo creare un'interfaccia che definisce i metodi standard e un assolutotracclasse t che implementa i metodi comuni.

• Interfaccia – è simile a una classe. Definisce solo i metodi e i parametri.
• Abstracclasse t – è una classe che non può essere utilizzata per creare direttamente un oggetto. Il suo scopo è fornire implementazioni parziali o totali di metodi comuni.

Il diagramma delle classi qui sotto illustra la relazione tra i nostri assolutitracClasse t, interfaccia e classi di implementazione.

Creiamo ora i nostri addominalitracclasse t.

<?php
abstract class DBCommonMethods
{
    private $host;
    private $db;
    private $uid;
    private $password;
    public function __construct($host, $db, $uid, $password)
    {
        $this->host = $host;
        $this->db = $db;
        $this->uid = $uid;
        $this->password = $password;
    }
}
?>

QUI,

• “asstrac"Classe t" significa che la classe non può essere utilizzata direttamente per creare un oggetto
• “$host, $db…” sono variabili di classe comuni a tutte le implementazioni
• “function __construct(…)” è il metodo costruttore della classe che imposta i valori delle variabili comuni all’inizializzazione

Creiamo ora l'interfaccia che contiene i metodi standard, che verranno implementati in modo diverso a seconda del motore del database.

<?php
interface DBInterface
{
    public function db_connect();
    public function insert($data);
    public function read($where);
    public function update($where);
    public function delete($where);
}
?>

QUI,

• “interfaccia” è la parola chiave per creare interfacce
• “funzione pubblica…(…)” sono i metodi standard che dovrebbero essere implementati

Creiamo ora le classi concrete che estenderanno la classe DBCommonMethods e implementeranno l'interfaccia DBInterface. Innanzitutto, MySQLDriver.php:

<?php
class MySQLDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

Quindi, MSSQLServerDriver.php:

<?php
class MSSQLServerDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

QUI,

• “class … extends DBCommonMethods” utilizza i metodi in DBCommonMethods
• “… implements DBInterface” garantisce che la classe fornisca i metodi standard indipendentemente dal driver del database utilizzato.

Il codice che utilizza le classi sopra descritte avrebbe questo aspetto:

<?php $db = new MySQLDriver($host, $db, $uid, $password); ?>

Oppure:

<?php $db = new MSSQLServerDriver($host, $db, $uid, $password); ?>

Il resto del codice sarebbe identico per entrambi i driver, ad esempio:

<?php
$db->db_connect();
$db->insert($data);
?>

Questo è il polimorfismo in azione: le stesse chiamate di metodo funzionano su qualsiasi driver che implementi l'interfaccia, quindi il codice circostante non cambia mai quando si cambia motore di database.

DOMANDE FREQUENTI