interactuar con una interfaz?

Question

por lo que he leído parece que uno puede interactuar con una interfaz?

por ejemplo. digamos que tengo una interfaz con un método vacío "comer()"

luego 2 subclases están implementando esta interfaz.

¿Mi controlador puede interactuar solo con la interfaz y usar el método eat()?

echar un vistazo a la imagen en este enlace strategy

Answer 1

No puede interactuar con una interfaz excepto para acceder a cualquier constantes definidas en ella o usarla para TypeHints. Las interfaces no tienen métodos bodys. Solo están destinados a definir un contrato que las clases implementadoras deben obedecer.

interface Logger 
{ 
    const FOO = 1; 
    public function log($msg); 
} 

echo Logger::FOO; // 1 
Logger::log($msg); // Fatal error: Cannot call abstract method Logger::log() 
new Logger;  // Fatal error: Cannot instantiate interface Logger 

Ver http://php.net/manual/en/language.oop5.interfaces.php

---

Lo que se entiende generalmente cuando codificación contra una interfaz o interactúa con una interfaz es básicamente nada más que métodos de llamada definidos en una interfaz en las clases que los implementan. Llamas a la implementación, no a la definición. La definición solo especifica que para cada Clase que implementa la interfaz, tiene que haber un método específico con los argumentos especificados.

Considere estas clases:

Class DbLog implements Logger 
{ 
    public function log($msg) { /* log $msg to database */ } 
} 

Class FileLog implements Logger 
{ 
    public function log($msg) { /* log $msg to file */ } 
} 

Ambas clases de aplicar Logger y por lo tanto tiene que tener un método log($msg). Básicamente estás diciendo: "hey class, si quieres ser un Logger, asegúrate de que puedo llamar a log() contigo".. Ahora en algún lugar de su código que podría tener una clase que necesita un registrador, como

class Foo 
{ 
    protected $logger; 
    public function __construct(Logger $logger) 
    { 
     $this->logger = $logger; 
     $this->logger->log('I can haz logger! Yay!'); 
    } 
} 

Foo no le importa si se pone FileLog, DbLog o cualquier otro registrador concreta. Simplemente le importa que obtenga cualquier registrador que pueda llamar al log() en. Foo ni siquiera está interesado en lo que hace log(). Todo Foo se preocupa por poder llamar al log(). Sin embargo, no está llamando al log() en la interfaz. Lo está llamando en la clase reservada que se pasó al Foo, pero en un diagrama UML representaría esto como se muestra en la página que ha vinculado, porque acaba de codificar en una interfaz.

La principal ventaja de esto es que sus clases están mucho menos acopladas. Puede intercambiar dependencias más fácilmente, por ejemplo cuando usa Mocks en pruebas unitarias, y su código será más fácil de mantener.

Básicamente, piense en una interfaz como una estandarización conceptual. Por ejemplo, cuando compra un reproductor de DVD nuevo, espera que tenga un botón ► que de alguna manera (no le importa cómo, solo eso) hace que el reproductor reproduzca el DVD.Cuando presiona ese botón, no está presionando la especificación general de la interfaz de DVD abstracta que dice que un reproductor de DVD debe tener un botón de reproducción, pero hizo clic en la implementación concreta de un botón de reproducción en esta marca de jugador.