Interfaces ( Herencia de interfaz)

Como vimos en la sesión de introducción existen dos tipos de herencia, la herencia de implementación, que es una herencia simple en la que reutilizamos código y la herencia de interfaz en la cual heredamos una lista de propiedades y métodos vacíos para que su codificación sea personalizada.

Este tipo de herencia es una solución elegante para solventar la no posibilidad de herencia múltiple.

El comportamiento es similar a otros lenguajes orientados a objetos como Java o .NET. Una interfaz es una especie de contrato: se definen una serie de funciones vacías sin aportar su implementación. Quienquiera cumplir con una determinada interfaz deberá implementar todos y cada uno de los métodos declarados en la interfaz. En otras palabras, tendremos que crear una clase que implemente dicha interfaz.

Se permite la herencia entre interfaces y una clase podrá 'heredar' de más de un interfaz.

Las interfaces nos permiten definir comportamientos comunes entre clases dispares que no se relacionan evitando crear relaciones forzadas y colisiones de nombres.

Utilizaremos la palabra reservada "**interface** " seguida de un identificador para el mismo al que podremos anteponerle por ejemplo la letra 'I' para saber que se trata de un interfaz. Seguidamente y entre llaves colocaremos las cabeceras de métodos sin cuerpo, que deberán codificar la clase que implemente el interfaz.

La clase que implementa una interfaz llevará la palabra reservada **implements** en la definición de la misma justo después del nombre la clase o del nombre de la clase Padre en el que caso que sea una clase que herede de otra.

Más adelante veremos las clases abstractas, que principalmente se diseñan como clases base para que otras hereden de ella y no se permite crear instancias de esas clases base. Por lo tanto, podríamos decir que una interfaz es similar a una clase abstracta en la cual no se incluye ninguna implementación de código.

Un buen ejemplo:

<?php
   interface IDisplayable {
      function Imprimir();
   }
   interface IDestructor {
      function Destructor();
   }
   class A {
      protected $datoA;
      public function __construct($pDatoA) {
         $this->datoA = $pDatoA;
      }
   }
   class B extends A implements IDisplayable, IDestructor // Estilo Java
   {
      private $datoB;
      public function __construct($pDatoB, $pDatoA) {
         parent::__construct($pDatoA);
         $this->datoB = $pDatoB;
      }
      // Metodo forzado a implementar por el interfaz IDestructor
      public function Destructor() {
         $this->datoB = null;
      }
      // Metodo forzado a implementar por el interfaz IDisplayable
      public function Imprimir() {
         echo sprintf(" %04d %04d", $this->datoB, $this->datoA);
      }
   }
   $objs[0] = new A(100);
   $objs[1] = new B(200, 300);
   foreach ($objs as $obj)
   {
      if ($obj instanceof IDisplayable)
         echo $obj->Imprimir();
   }
?>

Daría como resultado:

0200 0300

Cabe destacar que no se puede crear una instancia de una interfaz, si lo hacemos se producirá un error fatal.