En este post explicaremos que son las interfaces y las clases abstractas, y para que utilizaremos cada una de ellas.
Interfaces
Las interfaces de objetos permiten crear código con el cual especificamos qué métodos deben ser implementados por una clase, sin tener que definir cómo estos métodos son manipulados. Las interfaces son definidas utilizando la palabra clave interface, de la misma forma que con clases estándar, pero sin métodos que tengan su contenido definido. Todos los métodos declarados en una interfaz deben ser public, ya que ésta es la naturaleza de una interfaz.
Por lo general, utilizaremos las interfaces cuando queramos asegurarnos de que una clase implemente una serie de métodos. Veamos un ejemplo:
// Declarar la interfaz 'iTemplate'
interface iTemplate {
public function setVariable($name, $var);
public function getHtml($template);
}
// Implementar la interfaz
// Ésto funcionará
class Template implements iTemplate {
private $vars = array();
public function setVariable($name, $var) {
$this->vars[$name] = $var;
}
public function getHtml($template) {
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}
// Ésto no funcionará
// Error fatal: La Clase BadTemplate contiene un método abstracto
// y por lo tanto debe declararse como abstracta (iTemplate::getHtml)
class BadTemplate implements iTemplate {
private $vars = array();
public function setVariable($name, $var) {
$this->vars[$name] = $var;
}
}
Clases abstractas
Mientra que las interfaces sólo nos permiten compartir comportamientos entre objetos no relacionados, las clases abstractas permiten limitar y/o definir con precisión las capacidades de cada objeto. No se puede instanciar directamente a una clase abstracta, sino que habrá que crear otra clase que herede de esta (usando extends) y desde esta se podrán realizar las operaciones sobre los métodos o parámetros de la clase abstracta. En una clase abstracta se pueden definir métodos públicos, que serán accesibles desde las clases heredadas sin necesidad de sobreescribirlas.
Veamos un ejemplo de abstracción de clases:
abstract class AbstractClass
{
// Forzando la extensión de clase para definir este método
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// Método común
public function printOut() {
print $this->getValue() . "\n";
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}
class ConcreteClass2 extends AbstractClass
{
public function getValue() {
return "ConcreteClass2";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') ."\n";
En este ejemplo podemos ver como las clases ConcreteClass1 y ConcreteClass2 extienden de AbstractClass y se llama al método abstracto printOut() para mostrar el resultado.
