Diferencia entre clase Abstracta y interfaz

[hhs]

Ya con un poco mas de tiempo he decidido ampliar un poco este hilo para aclarar la duda de juan14_nob y que considero es una duda común.

¿Herede o Implemente va a ser lo mismo?

No, no es lo mismo las interfaces y las clases abstractas son conceptos diferentes

Una interfaz es la descripción de las acciones que puede realizar un objeto

Una clase abstracta es aquella cuyo propósito principal es definir una interfaz común para sus subclases.

La interfaz describe un objeto desde afuera o si lo prefieres su abstracción es decir; una interfaz (abstracción de un objeto) te dice lo que puede hacer un objeto sin conocer su detalles internos.
Para fines prácticos esto quieres decirr que cuando modelo un objeto en PHP puedo declarar la abstracción mediante la interfaz y además su comportamiento interno mediante una clase.
En otras palabras un objeto en un lenguaje puede ser definido de la siguiente forma

Objeto = interfaz (abtracción) + su clase (implementación)

Las clases abstractas es el equivalente de una interfaz pero para una jerarquía de objetos, como es la abstracción del comportamiento de una jerarquía no se pueden instanciar directamente. Un ejemplo del mundo real lo puedes apreciar en los smartphone todos comparte características y funcionalidad similares, pero cuando usas uno no tienes un objeto smartphone, si no mas bien un objeto concreto del tipo smart phone (Samsung GT-E1205, LG D950-G Flex, etc.)

Ahora vamos a traducir todo esto a un ejemplo en PHP, para esto voy a usar una definición de reloj y vamos a modelarlo de forma muy sencilla para centrarnos en los conceptos que mencione antes.

Reloj (objeto) : Instrumento para medir el tiempo o para indicar la hora del día (lo que hace); puede ser fijo o portátil y el más común para indicar la hora consiste en una maquinaria de movimientos uniformes que hace avanzar unas manecillas sobre una superficie esférica, marcando el paso del tiempo.

De la definición se puede determinar que la razón de ser de un reloj es proporcionarme la hora del día. Claro esta que también conocemos por experiencia que puede proporcionarnos la fecha actual entre otras cosas. Pero como lo comente vamos a dejarlo sencillo, así que podemos representar la abstracción de un reloj de la siguiente forma en php.

Código PHP:

interface Reloj
{
    public function hora();
}
 

Con la interfaz estoy declarando las posibles variantes que puede tener un objeto Reloj y lo útil de esto es que puedo usar la interfaz antes de haber escrito siquiera una clase concreta de reloj. Para esto crearemos una persona que pueda usar un reloj de cualquier tipo.

Código PHP:

class Persona {
    private $reloj;
 
    public function usar(Reloj $reloj){
        $this->reloj = $reloj;
 
        return $this;
    }
 
    public function verLaHora(){
        return 'Reloj: '.get_class($this->reloj).' Hora: '.$this->reloj->hora();
    }
}
 

Para probar la utilidad de la interfaz voy a crear diferentes relojes que me proporcionen la hora y la fecha en diferentes formatos.

• Formato de 12 horas
• Formato de 12 horas y fecha
• Formato de 12 o 24 horas
• Formato configurable de 12 o 24 horas y formato de fecha configurable

Código PHP:

class RelojDePared implements Reloj{
 
    // formato de 12 horas
    public function hora()
    {
        return date('h:i:s a');
    }
}
 
class RelojPuslsoClasico implements Reloj {
 
    private $dateTime;
 
    public function __construct()
    {
        $this->dateTime = new DateTime();
    }
 
    //formato de 12 horas y fecha del día
    public function hora()
    {
        return $this->dateTime->format('h:i:s A, d M y');
    }
}
 
class RelojPulsoDigital implements Reloj {
    private $dateTime;
 
    private $formato = [
        12 => 'h:i:s a',
        24 => 'H:i:s'
    ];
 
    private $formatoHora;
 
    public function __construct($formatoHora = 12)
    {
        $this->dateTime = new DateTime();
        $this->formatoHora = $formatoHora;
    }
 
    //formato de 12 o 24 horas
    public function hora()
    {
        return $this->dateTime->format($this->formato[$this->formatoHora]);
    }
}
 
class RelojDigitalConCalendario implements Reloj{
 
    private $dateTime;
 
    private $formatoHora;
 
    private $formatoFecha;
 
    public function __construct($formatoHora = 'h:i:s a', $formatoFecha = 'Y-m-d')
    {
        $this->dateTime = new DateTime();
        $this->formatoHora = $formatoHora;
        $this->formatoFecha = $formatoFecha;
    }
 
    // formato de 12 o 24 hrs y fecha del día
    public function hora()
    {
        return $this->dateTime->format(
            sprintf('%s %s', $this->formatoHora, $this->formatoFecha)
        );
    }
}
 

Creamos instancias de cada reloj y probamos que las use Persona:

Código PHP:

$relojPared = new RelojDePared();
$relojClasico = new RelojPuslsoClasico();
$relojDigital = new RelojPulsoDigital();
$relojDigital24 = new RelojPulsoDigital(24);
$relojDigitalConCalendario = new RelojDigitalConCalendario();
$mejorReloj = new MejoraRelojDigital();
 
 
$persona = new Persona();
echo $persona->usar($relojPared)->verLaHora() .'<br>';
echo $persona->usar($relojClasico)->verLaHora() .'<br>';
echo $persona->usar($relojDigital24)->verLaHora() .'<br>';
echo $persona->usar($relojDigital)->verLaHora() .'<br>';
echo $persona->usar($relojDigitalConCalendario)->verLaHora() .'<br>';
 

Si te das cuenta todas las clases hace su trabajo interno de forma diferente pero como están implementando la interfaz Reloj esto no marcara diferencia alguna para el objeto persona que puede usar cualquiera de los relojes que implementamos.

Hasta aquí espero que ya este claro el concepto de interfaz. Para tratar el tema de clase abstracta vamos a emplear lo que ya tenemos echo.
Si te das cuenta algunos de las implementaciones de los relojes comparten casi el mismo código lo único diferente es el formato que entregan.

Si seguimos agregando implementaciones puede llegar un punto en el que tengamos varias clases repitiendo el mismo código así que puedes agruparlo y no estarlo repitiendo. Así que crearemos una clase abstracta que contenga ese código que puede extenderse para implementar nuevos relojes.

Código PHP:

abstract class AbstractReloj implements Reloj {
 
    protected  $dateTime;
 
    protected  $formatoHora;
 
    protected  $formatoFecha;
 
    public function __construct($formatoHora = 'h:i:s a', $formatoFecha = 'Y-m-d')
    {
        $this->dateTime = new DateTime();
        $this->formatoHora = $formatoHora;
        $this->formatoFecha = $formatoFecha;
    }
    public function hora()
    {
      return $this->dateTime->format($this->formato());
    }
 
    abstract public function formato();
 
}
 
class MejoraRelojDigital extends AbstractReloj{
 
    // formato 12 o 24 horas y fecha del día
    public function formato()
    {
        return sprintf('[ %s, %s ]',$this->formatoHora, $this->formatoFecha);
    }
}
 

Probamos nuestro cambio nuevamente

Código PHP:

$mejorReloj = new MejoraRelojDigital();
$persona = new Persona();
echo $persona->usar($mejorReloj)->verLaHora() .'<br>';
 

Si hiciste la prueba puedes apreciar que el reloj funciono sin ningún problema. La utilidad de las interfaces y las clases abstractas es que te permiten crear código mas flexible a los cambios, y eso lo pueden notar en que hicimos diferentes objetos y en cada caso no tuvimos que cambiar al objeto persona para que nuestro código siguiera funcionando.


El ejemplo es sencillo pero espero que con esto se aclare un poco la diferencia entre las interfaces y las clases abstractas lo siguiente es que experimentes con ellas.