Programatik

Supongamos la siguiente situación:

Tenemos que implementar un objeto que representa una figura. Sus propiedades serán base y altura. El único método será area, que calculará el área de la figura.

Obviamente, el área se calculará de una forma u otra dependiendo de qué figura se trate.

Una primera aproximación podría llevarnos a esto:

Class Shape {
	private $base;
	private $height;
 
	public function Shape($base, $height) {
		$this->base = $base;
		$this->height = $height;
	}
 
	public function area($type) {
		switch ($type) {
			case 'rectangle':
				return $this->base * $this->height;
				break;
 
			case 'triangle':
				return ($this->base * $this->height) / 2;
				break;
		}
	}
 
//
}

Y así deberíamos ir colocando todas las posibles figuras distintas en los casos del switch.

Sin embargo, esto nos obliga a estar editando esta clase cada vez que queramos incluir una figura nueva a la que calcular su área.

Una solución más elegante la proporcionan las clases abstractas. Una clase abstracta permite definir un objeto que no será instanciado, pero del que podremos heredar para crear objetos nuevos.

En el ejemplo de la figura, el código quedaría así:

Abstract Class Shape {
	protected $base;
	protected $height;
 
	abstract public function area();
}

Observamos que el método area presenta solo su signatura. Su implementación debe realizarse en las clases que hereden de Shape. De este modo, podemos crear un objeto por cada figura distinta que necesitemos para trabajar.

Por ejemplo:

Class Rectangle extends Shape {
	public function Rentangle($base, $height) {
		$this->base = $base;
		$this->height = $height;
	}
	public function area() {
		return $this->base * $this->height;
	}
}
 
Class Triangle extends Shape {
	public function Triangle($base, $height) {
		$this->base = $base;
		$this->height = $height;
	}
	public function area() {
		return ($this->base * $this->height) / 2;
	}
}

o cualquier otra figura que queramos.

Este ejemplo es muy obvio y puede encontrarse en la documentación de PHP, en uno de sus comentarios. Un ejemplo de uso menos trivial sería el siguiente:

Imaginemos que tenemos una serie de tablas distintas en una base de datos pero que tienen la misma estructura, formada por un identificador, ID, y un campo Name.

Podríamos crear varios objetos, uno por cada una de esas tablas, para manejar la selección y edición de datos de las mismas. Como es natural, esto se hace muy pesado porque estamos repitiendo código sin motivo. Es mejor utilizar una clase abstracta:

Abstract Class NamedList {
 
	protected $id;
	protected $name;
 
	public $data = array();
 
	public function setID($id) {
		$this->id = $id;
	}
	public function setName($name) {
		$this->name = $name;
	}
	public function getID() {
		return $this->id;
	}
	public function getName() {
		return $this->name;
	}
	public function getData() {
		return $this->data;
	}
 
//
}

A partir de ella podemos crear objetos que se encarguen solo del acceso a los datos:

Class TableManagement extends NamedList {
	public function add() {
	}
	public function update($id) {
	}
	public function delete($id) {
	}
 
	// ...
}

Enlaces