Redazione
a- a+

Il polimorfismo

Vediamo che cosa è il polimorfismo e come utilizzarlo per costruire pagine web dinamiche. Codici ed esempi.

Il polimorfismo è una caratteristica esposta da alcuni oggetti che appartengono alla stessa famiglia che, alla fine, può comportarsi in modo diverso, anche quando si stanno utilizzando metodi identici. O, più chiaramente, un oggetto può essere considerato polimorfo quando è in grado di svolgere diverse azioni utilizzando lo stesso metodo.

Come si nota, questa caratteristica può essere molto utile in certe situazioni in cui l'utilizzo di oggetti polimorfici in grado di migliorare sensibilmente il modo in cui una specifica applicazione è strutturata, oltre a evitare l'inserimento nel codice sorgente di block ridondanti di controllo (come il famoso "if  else” oppure  “switch /case").

Come utilizzare il polimorfismo per costruire pagine web dinamiche?

Prima di tutto definiamo, in cima alla gerarchia corrispondente, una classe base che dichiara un paio di metodi generici. Successivamente costruiamo alcune sottoclassi dal genitore di cui sopra.

Tutti gli oggetti della pagina web presentano un metodo chiamato "display ()", adibito a differenti azioni a seconda del tipo di elemento che viene visualizzato dalla pagina web. In questo modo implementiamo il polimorfismo negli oggetti.

Ora che è chiaro come utilizzare il polimorfismo per costruire le pagine web dinamiche, vediamo la classe base di seguito riportata e che delinea la struttura generica di un oggetto.

// definiamo la classe 'WebPageElement' 
class WebPageElement{
protected $data;
protected $id;
protected $class;
public function __construct($data,$id,$class){
if(!$data){
  throw new Exception('Il contenuto per un elemento di una pagina web non devono essere tringhe vuote.');
  }
$this->data=$data;
if($id){
   if(!preg_match("/^[a-z]+$/",$id)){
      throw new Exception('Attributo ID non valido.');
   }
   else{
      $this->id=$id;
   }
}
if($class){
      if(!preg_match("/^[a-z]+$/",$class)){
          throw new Exception('attributo class non valido.');
      }
      else{
          $this->class=$class;
      }
  }
}
    public function display(){}
}

Come è possibile osservare, "WebPageElement" presenta solo il metodo "display ()", a parte il costruttore corrispondente. Inoltre, la classe in questione accetta, come argomenti di input, ID e attributi di classe.

Come si è visto, la classe genitore precedente implementa solo una logica primitiva, utile per la convalida dei diversi argomenti presi in arrivo dal costruttore.

Detto questo, definiamo dinamicamente i tag HTML <h1>, <h2> e <h3> rispettivamente. Le loro definizioni sono le seguenti:

// definizione della classe 'H1' 
class H1 extends WebPageElement{
public function __construct($data,$id,$class){
parent::__construct($data,$id,$class);
}
public function display(){
$html='<h1';
if(!empty($this->id)){
     $html.=' id="'.$this->id.'"';
}
if(!empty($this->class)){
     $html.=' class="'.$this->class.'"';
}
$html.='>'.$this->data.'</h1>';
return $html;
}
}
// definizione della classe 'H2' 
class H2 extends WebPageElement{
public function __construct($data,$id,$class){
parent::__construct($data,$id,$class);
}
public function display(){
$html='<h2';
if(!empty($this->id)){
   $html.=' id="'.$this->id.'"';
}
if(!empty($this->class)){
   $html.=' class="'.$this->class.'"';
}
$html.='>'.$this->data.'</h2>';
return $html;
}
}
// definizione della classe 'H3' 
class H3 extends WebPageElement{
public function __construct($data,$id,$class){
parent::__construct($data,$id,$class);
}
public function display(){
$html='<h3';
if(!empty($this->id)){
    $html.=' id="'.$this->id.'"';
}
if(!empty($this->class)){
    $html.=' class="'.$this->class.'"';
}
$html.='>'.$this->data.'</h3>';
return $html;
}
}

Le tre sottoclassi implementano concretamente il "display ()", ovvero lo stesso metodo usato per generare il markup necessario che corrisponde all’ (X)HTML header già menzionato.

Tuttavia, la cosa più importante da evidenziare sono i diversi comportamenti esposti dal metodo in questione, in quanto svolge diverse azioni a seconda del tipo di oggetto nella pagina web che lo richiama.

Questo fatto dimostra proprio che le sottoclassi precedenti sono polimorfiche, poiché appartengono alla stessa famiglia, ma ognuna si comporta diversamente.



Ti potrebbe interessare anche

commenta la notizia

Ci sono 1 commenti