Connessione a MySQL con una classe astratta

Per classe astratta si intende indicare una classe che funge da "prototipo" per le classi che da essa derivano; in pratica una classe astratta non ha "corpo" e non può essere istanziata, quindi anche i metodi di questo tipo di classe sono astratti e vengono implementati nelle secondarie che da essa derivano.

Il discorso può sembrare complicato ma in realtà non lo è, infatti una classe astratta funge essenzialmente da "modello" per metodi che potranno essere richiamati nelle sotto-classi senza dover essere ridefiniti. Nel momento in cui istanzieremo la sotto-classe di un'astratta la prima saprà già quali funzioni svolgere sulla base delle indicazioni definite nel prototipo.

Per dar vita ad una classe astratta esiste un costrutto apposito, abstract , che può essere associato anche alla funzione svolta nella classe; i metodi interni alla classe potranno essere "visibili" o meno a seconda degli attributi stabiliti dallo sviluppatore che potrà scegliere tra 3 livelli di visibilità:

1. public: visibilità di un elemento estesa all'intera applicazione;
2. private: visibilità di un elemento limitata alla sola classe in cui viene definito;
3. protected: la visibilità di un elemento limitata alla classe in cui è definito e alle sue classi derivate.

La definizione della struttura dei dati è messa a disposizione da un elemento chiamato costruttore, richiamabile attraverso la sintassi __construct(), che l'applicazione richiamerà nel momento in cui viene definito un oggetto.

Gli ambiti di applicazione delle classi astratte sono i più vari, ma in questo breve tutorial ne analizzaremo uno sicuramente di largo utilizzo; creeremo infatti una superclasse in grado di mettere a disposizione di una sottoclasse i metodi per la connessione al DBMS MySQL e per la selezione di un database.

Vediamo il nostro codice:

// definizione della classe astratta
abstract class ConnessioneMySQL
{
  // definizione della classe astratta 
  abstract function DatiConnessione();

  // introduzione dei metodi concreti che definiscono
  // i parametri di connessione e selezione 
  protected function settaUtente($user)
  {
    $this->Utente = $user;
  }

  protected function settaPassword($password)
  {
    $this->Password = $password;
  }

  protected function settaHost($host)
  {
    $this->Host = $host;
  }

  protected function settaDb($db)
  {
    $this->Db = $db;
  }

  protected function getUtente()
  {
    return ($this->Utente);
  }

  protected function getPassword()
  {
    return ($this->Password);
  }

  protected function getHost()
  {
    return ($this->Host);
  }

  protected function getDb()
  {
    return ($this->Db);
  }
}

Come è possibile notare, abbiamo deciso di definire all'interno della classe astratta soltanto metodi con visibilità protected, questi saranno quindi tutti visibili anche per la sotto-classe da essa derivata.

Grazie al principio dell'ereditarietà la sottoclasse avrà a disposizione attributi e metodi messi a disposizione dalla classe principale. La sintassi dell'ereditarietà è abbastanza semplice:

class derivata extends principale

Il costrutto extends sarà sufficiente per imporre all'applicazione di conferire tutti i membri della classe primaria a quella ereditiera.
Vediamo quindi un esempio di sotto-classe utilizzabile all'interno della nostra applicazione:

// erdeitarietà della sottoclasse
class ConnettiMySQL extends ConnessioneMySQL
{
  // definizone del costruttore
  public function __construct()
  {
    $this->settaHost('localhost');
    $this->settaUtente('webmaster');
    $this->settaPassword('parolachiave');
    $this->settaDb('agenda');
  }
  
  // chiamata della funzione astratta
  public function DatiConnessione()
  {
    $this-> getHost();
    $this-> getUtente();
    $this-> getPassword();
    $this-> getDb();
    mysql_connect($this->getHost(), $this->getUtente(), $this->getPassword());
    mysql_select_db($this->getDb());
  }
}

// istanza della classe
$connessione = new ConnettiMySQL();
$connessione->DatiConnessione();

Come è possibile notare, ad essere istanziata non è la classe principale, astratta, ma la classe derivata che ne ha ereditato metodi e attributi.