Tutorial sul concetto di programmazione orientata agli oggetti PHP (OOP) con esempio

Cos'è l'OOP?

Object Oriented è un approccio allo sviluppo software che modella l'applicazione attorno a oggetti del mondo reale come dipendenti, automobili, conti bancari, ecc. Una classe definisce le proprietà e i metodi di un oggetto del mondo reale. Un oggetto è un'occorrenza di una classe.

I tre componenti fondamentali dell'orientamento 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 principali dell'OOP sono;

• incapsulamento – questo riguarda il nascondere i dettagli di implementazione e l'esporre solo i metodi. Lo scopo principale dell'incapsulamento è;
• Ridurre la complessità dello sviluppo del software: nascondendo i dettagli di implementazione ed esponendo solo le operazioni, l'utilizzo di una classe diventa semplice.
• Proteggi lo stato interno di un oggetto: l'accesso alle variabili della classe avviene tramite metodi come get e set, questo rende la classe flessibile e facile da mantenere.
• L'implementazione interna della classe può essere modificata senza preoccuparsi di danneggiare il codice che utilizza la classe.
• Eredità – si tratta del rapporto tra le classi. La relazione assume la forma di un genitore e figlio. Il figlio utilizza i metodi definiti nella classe genitore. Lo scopo principale dell'eredità è;
• Riutilizzabilità: più figli possono ereditare dallo stesso genitore. Ciò è molto utile quando dobbiamo fornire funzionalità comuni come l'aggiunta, l'aggiornamento e la cancellazione dei dati dal database.
• Polimorfismo – si tratta di avere un unico modulo ma molte modalità di implementazione diverse. Lo scopo principale del polimorfismo è;
• Semplifica la manutenzione delle applicazioni e rendile più estensibili.

OOP Concepts nel PHP

PHP è un linguaggio di scripting orientato agli oggetti; supporta tutti i principi di cui sopra. I principi di cui sopra vengono raggiunti tramite;

• incapsulamento – tramite l’uso dei metodi “get” e “set” ecc.
• Eredità – tramite l'uso della parola chiave extends
• Polimorfismo – tramite l'uso della parola chiave implements

Ora che abbiamo le conoscenze di base dell'OOP e di come è supportato PHP, esaminiamo esempi che implementano i principi di cui sopra

Cos'è UML?

Unified Modeling Language UML è una tecnica utilizzata per progettare e documentare sistemi orientati agli oggetti.

UML produce una serie di documenti, ma esamineremo il diagramma delle classi che è molto importante per la programmazione php orientata agli oggetti.

Esempio di diagramma di classi

Chiave del diagramma di classi

• Il Scatola superiore contiene il nome della classe
• Il casella centrale contiene le variabili di classe
• Il scatola inferiore contiene i metodi della classe
• Il meno (-) segno significa ambito privato
• Il più (+) il segno significa ambito pubblico
• Il 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

Diciamo che vogliamo creare una classe per rappresentare gli animali.

Inizieremo identificando le caratteristiche comuni a tutti gli animali.

• Tutti gli animali appartengono a una famiglia come un erbivoro, un carnevale, ecc.
• Tutti gli animali mangiano cibo

Il diagramma seguente mostra il diagramma dell'animale

Ora codifichiamo la nostra classe animale

<?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 non è possibile accedere alle variabili direttamente all'esterno della classe (Incapsulamento).
• "funzione pubblica __construct($family...)" è il metodo di costruzione 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.

Nota che la mucca eredita dalla classe animale e definisce anche la propria variabile e i propri metodi.

Ora codifichiamo la 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 codifichiamo la classe Lion

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

QUI,

• "class... extends Animal" fa sì che la mucca e il leone 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('Canirval', '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

Visualizziamo ora la nostra applicazione in un browser web

Fantastico, vero! Consideriamo ora il terzo principio dell'OOP, il polimorfismo.

Diciamo che vogliamo sviluppare un'applicazione che si connetta a diversi motori di database come MySQL e SQL Server ma utilizza la stessa interfaccia uniforme.

Possiamo creare un'interfaccia che definisce i metodi standard e una classe astratta che implementa i metodi comuni.

• Interfaccia – è simile a una classe. Definisce solo i metodi e i parametri.
• Classe astratta – è 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 riportato di seguito illustra la relazione tra la nostra classe astratta, l'interfaccia e le classi di implementazione.

Creiamo ora la nostra classe astratta

<?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,

• "classe astratta" significa che la classe non può essere utilizzata direttamente per creare oggetti php
• “$host,$db…” sono variabili di classe comuni a tutte le implementazioni
• "function __construct(...)" è il metodo di costruzione della classe php 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 ed estenderanno l'interfaccia DBInterface. 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 } 
} ?>

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
• "... implementa DBInterface" garantisce che la classe fornisca metodi standard indipendentemente dal driver del database utilizzato.

Utilizzo del codice precedente Il codice che utilizza la classe precedente sarebbe simile a questo

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

Or

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

Il resto del codice sarebbe lo stesso per entrambi i driver come;

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

Sommario

• La programmazione orientata agli oggetti OOP è una potente tecnica che modella le applicazioni su oggetti del mondo reale
• Una classe è una rappresentazione di oggetti del mondo reale con proprietà e metodi
• I tre principi fondamentali dell'OOP sono;
• incapsulamento
• Eredità
• Polimorfismo