Utilizzare le classi astratte

Forti della panoramica teorica della precedente lezione, possiamo ora passare ad osservare le classi astratte in azione. Prendiamo come esempio quello dichiarato precedentemente, in cui i tre Team di sviluppo creano una gerarchia di classi e vogliono condividere le stesse API, elevandolo con un esempio concreto.

Supponiamo che la classe astratta di base (che chiameremo Product) contenga dei metodi per creare ed ottenere informazioni su di un prodotto, mentre le classi InProduct ed OutProduct si occuperanno di fornire informazioni rispettivamente sui prodotti locali ed esterni, così come dell'acquisto e della vendita.

// Team A - Class Product
abstract class Product {
	// proprietà pubbliche
	public $name;
	public $price;
	// metodi pubblici
	public function __construct($name, $price) {
		$this->name = $name;
		$this->price = $price;
	}
	public function getName() {
		return $this->name;
	}
	public function getPrice() {
		return $this->price;
	}
	// metodi astratti
	abstract public function buyProduct($pid, $quantity);
	abstract public function sellProduct($pid, $quantity);
}

La classe Product, deve essere necessariamente estesa tramite nuove sottoclassi che devono obbligatoriamente ridefinire i suoi metodi astratti, in questo caso quelli denominati buyProduct (comprare un prodotto locale/esterno) e sellProduct (vendere un prodotto locale/esterno):

// Team B - Class InProduct
class InProduct extends Product {
	public function buyProduct($pid, $quantity) {
		// connettiamoci al nostro database locale per ottenere i prodotti che dobbiamo comprare con la quanità indicata...
		$prods = connect_to_my_local_db($db->login(), $quantity);
		$prods->sendmail("buy");
		// ...
	}
	public function sellProduct($pid, $quantity) {
		// connettiamoci al nostro database locale per ottenere i prodotti che dobbiamo vendere con la quanità indicata...
		$prods = connect_to_my_local_db($db->login(), $quantity);
		$prods->sendmail("sell");
		// ...
	}
}
// Team C - Class OutProduct
class OutProduct extends Product {
	public function buyProduct($pid, $quantity) {
		// connettiamoci al database del partner per ottenere i prodotti che dobbiamo comprare con la quanità indicata...
		$prods = connect_to_partner_db($db->login(), $quantity);
		$prods->sendmail("buy");
		// ...
	}
	public function sellProduct($pid, $quantity) {
		// connettiamoci al database del partner per ottenere i prodotti che dobbiamo vendere con la quanità indicata...
		$prods = connect_to_partner_db($db->login(), $quantity);
		$prods->sendmail("sell");
		// ...
	}
}

Ovviamente, le funzioni ed i metodi utilizzati internamente sono inventati a puro scopo illustrativo (in uno scenario reale possono essere dichiarati, ad esempio, in altri file dell'applicazione). Ciò che è importante capire, è che nonostante le classi InProduct ed OutProduct siano create da diversi team di sviluppo, esse assumono una forma comune, coerente con quella indicata dalla classe astratta Product.

Tutte e tre le classi dunque, possono essere utilizzate nella stessa applicazione per costituire una API:

$pen = new InProduct("penna", 3.50);
$pencil = new OutProduct("matita", 3.50);
// vendiamo la penna
$pen->sellProduct(1102, 1);
// compriamo una matita
$pencil->buyProduct(3498, 1);
// ...

Conclusione

Con queste ultime due lezioni abbiamo imparato ad utilizzare le classi astratte e soprattutto a capirne l'importanza. Tuttavia, è errato credere che basti implementare delle classi astratte per ottenere un'applicazione solida ed uniforme, ma occorre progettare ogni singola caratteristica nel dettaglio fin dalle basi dell'applicazione stessa: ne consegue che le classi astratte sono solo il mezzo utile al raggiungimento di questo scopo. Ma queste classi particolari non sono le uniche componenti utili alla creazione di API uniformi: nella prossima lezione vedremo infatti le interfacce, nuovi strumenti al servizio delle infinite possibilità della OOP.