Interfaces

Sigo pensando que una interfaz es como una plantilla, una plantilla estricta que te dice qué es lo que debes de poner de manera obligatoria y ya tu terminas de rellenarla con los datos que necesites, en este caso, una plantilla de una clase.

Compañeros, una interface es un elemento de “Análisis Orientado a Objetros (por cierto, debería haber un curso de esto antes de POO para entender bien este mundo)” donde lo que se busca es romper dependencias estrictas de un objeto X con un objeto Y y ser más flexibles. Esto lo van a ver mucho cuando empiecen a trabajar en proyectos complejos. Voy a tratar de hacer un ejemplo:

Supongamos que tienes una empresa de transporte y tienes una flota de taxis y personas que solicitan el servicio:

<?php

class Taxi
{
    public $matricula;

    public function __construct($matricula)
    {
        $this->matricula = $matricula;
    }
    
    public function viajar($inicio, $destino)
    {
        return "Se ha trasladado desde $inicio hasta $destino";
    }

}


class Person 
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function solicitarTraslado(Taxi $taxi, $lugarInicio, $lugarDestino)    
    {
        echo "$this->name ha solicitado servicio de traslado del vehículo $taxi->matricula</br>";
        echo $taxi->viajar($lugarInicio, $lugarDestino);
    }
}

$taxi = new Taxi("ABC123");
$persona = new Person("José");
$persona->solicitarTraslado($taxi,"Av Fuerzas Armadas", "Av Baralt");

Ahora imaginen que te fue muy bien en tu negocio y no solo tienes taxis, ahora tienes aviones, trenes, barcos (Wao!!! adoptame!! jejeje)… Bueno deben modificar su sistema porque ahora el cliente puede solicitar un traslado en cualquier tipo de transporte que tengamos. Si ven, aquí tenemos una dependencia estricta de dos objetos:

class Person 
{
    public $name;

    public function__construct($name)
    {
        $this->name= $name;
    }

    public function solicitarTransporte(Taxi $taxi (AQUÍ!!!!),
 $lugarInicio, $lugarDestino)    
    {
        echo "$this->name he solicitado servicio de traslado del vehículo $taxi->matricula</br>";
        echo $taxi->viajar($lugarInicio, $lugarDestino);
    }
}

La persona solo puede solicitar traslado en taxi y queremos que pueda solicitar traslado en lo que tengamos. Aquí es donde entra la INTERFACE

Quiero que cualquier persona pueda trasladarse en los tipos de vehículos disponibles (taxi, barco y tren. Próximamente en unidades de spaceX jajajajaja). Deberíamos hacer esta implementación:

interface Transporte
{
    public function viajar($inicio, $destino);
}


class Taxi implements Transporte
{
    public $matricula;

    public $type = 'Taxi';

    public function __construct($matricula)
    {
        $this->matricula = $matricula;
    }
    
    public function viajar($inicio, $destino)
    {
        return "Se ha trasladado en el $this->type desde $inicio hasta $destino";
    }
}

class Barco implements Transporte
{
    public $matricula;

    public $type = 'Barco';

    public function __construct($matricula)
    {
        $this->matricula = $matricula;
    }
    
    public function viajar($inicio, $destino)
    {
        return "Se ha trasladado $this->type desde $inicio hasta $destino";
    }
}


class Tren implements Transporte
{
    public $matricula;

    public $type = 'Tren';

    public function __construct($matricula)
    {
        $this->matricula = $matricula;
    }
    
    public function viajar($inicio, $destino)
    {
        return "Se ha trasladado $this->type desde $inicio hasta $destino";
    }
}


class Person 
{
    public $name;

    public function __construct($name)
    {
        $this->name= $name;
    }

    public function solicitarTraslado(Transporte $transporte, $lugarInicio, $lugarDestino)    
    {
        echo "$this->name he solicitado servicio de traslado del vehículo $transporte->matricula</br>";
        echo $transporte->viajar($lugarInicio, $lugarDestino).'<hr>';
    }
}

$taxi = new Taxi("ABC123");
$persona = new Person("José");
$persona->solicitarTraslado($taxi,"Av Fuerzas Armadas", "Av Baralt");

$barco = new Barco("DEF456");
$persona = new Person("María");
$persona->solicitarTraslado($barco,"Av Fuerzas Armadas", "Av Baralt");

$tren = new Tren("XXX654");
$persona = new Person("Pablo");
$persona->solicitarTraslado($tren,"Av Fuerzas Armadas", "Av Baralt");

Si ven ahora lo que se le pasa a la clase Person es un objeto de tipo Transporte. Así rompemos la dependencia estricta de mi sistema que solo podía ofrecer traslados en taxi. Ahora a facturar más!!!

Espero este ejemplo haya aclarado el uso de las interfaces.

Interfaces

Una interfaz se desarrolla y se implementa en una clase, al implementarla nosotros estamos obligados a desarrollar todos los métodos que la interfaz define.

Esto quiere decir, que una interfaz no puede hacer nada por si sola, lo que significa que las clases hijas están encargadas de definir el comportamiento de todos los métodos abstractos de forma obligatoria.

En palabras más sencillas, las interfaces serán contratos que indicarán que es lo que se debe de hacer sin proveer ninguna funcionalidad.

<?php

class User {
    public $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

📌Una interfaz nos obliga a implementar los métodos que posee dentro de una clase.

Una interfaz es como un contrato, en ese contrato se especifican métodos que quiero que sean obligatorios implementar en una clase.

Aunque sigo sin entender bien el porque debo usar las interfaces, me quedo con que es una buena practica de programación y es la forma en que se debe hacer la programación profesional.

Una interfaz se desarrolla y se implementa en una clase. Al implementarse nosotros estamos obligados a desarrollar todos los métodos que la interfaz define.

Digamos que el que se va hacer se define en una Interfaz
y el como se va hacer y la implementación se define en una clase

-ItaloMorales

who is Lynda???

INTERFACES

Si quieres recordar bien esto, te dejo una referencia gráfica, con esto podemos decir.

La diferencia entre clase abstracta e interfaz es muy conceptual. La clase abstracta lo que hace es llevar la idea de algo abstracto a algo más concreto. Por ejemplo definimos una clase abstracta Transporte y decimos que un transporte tiene color, capacidad de pasajeros, cantidad de puertas (estos son atributos) y el Transporte puede acelerar y frenar (estos son métodos). La clase abstracta permite que al heredar en otras clases sus hijos pueden tener esos conceptos abstractos (todos los atributos y métodos que le definimos). De esta manera, todos sus hijos tienen transporte también. De hecho si hacemos un arreglo en un lenguaje fuertemente tipado y definimos que su tipo es Transporte, por poliformismo todos los hijos de transporte, entran en el array.

La interfaz habla más de comportamiento. Te dice qué comportamiento va a tener una clase que la implemente. Por ejemplo si implementamos Transporte (con los mismos métodos) como interfaz, sabemos que todas las clases que implementen necesitan acelerar y frenar porque ese es el comportamiento que se define con la interfaz.

La diferencia es conceptual pero a fines prácticos sirven para hacer lo mismo. Hoy en día se usa más la interfaz.

Las interfaces se definen de la misma manera que una clase,
aunque reemplazando la palabra reservada class por la palabra
reservada interface y sin que ninguno de sus métodos tenga su
contenido definido.

Según lo que he entendido , una interfaz es un requerimiento obligatorio mínimo para ser desarrollado en la implementación de una clase determinada.

"Crea la lógica necesaria, para que sea desarrollada a través de clases"

13. Interfaces

Aquella clase que implemente (implements) un interface, debe cumplir un contrato, es decir, está obligada a implementar los métodos que tiene la interface.

Comparto el código de la clase:

<?php

//contratos
// Database, get, delete, store, edit, update

interface Person
{
    public function getName();
}

class Admin implements Person
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }
}

$admin = new Admin('Aldo');
echo $admin->getName();

<?php
/**
 * ¿que se va a hacer?
 */
 //Ejemplo la clase persona  necesita nombre, apellido paterno, apelido materno
 // GetName es un metodo de php
interface Person
{
public function getName();

}

/**
 *  ¿como lo va a hacer?
 */
 class Admin implements Person
   {
       public $name;

       public function __construct($name)
       {
           $this->name = $name;  
       }

       public function getName() // funcion de la interfaz
       {
           return $this->name; // lo que te regresara
       }
   }
/**
 * crea un nuevo objeto con:
 */
 $admin = new Admin('linda');// en este espacio podemos poner el nombre que quueramos
    echo $admin->getName();


 ?>

Realmenete estaba muy escéptico en aprender php pero el profesor ha demostrado que esto es un gran lenguaje! Diría que mucho más fácil que javascrip se asemeja mucho al superSet typescript que hace que la programación orientada a objeto sea mas comprensible!

En este capítulo creo que lo tome el hilo.

Una Interfaz: Viene siendo la pre-implementación de la lógica y/o funciones/métodos/clases que se vaya a desarrollar para X módulo.

Como explica el profe:

creamos la interfaz Database:

En esta declaramos todos los métodos que su clase o función deberían de existir.

Pero una pregunta, este archivo válida que esas funciones o métodos son creados en otro lado?

Para mi una interfaz es un contrato, que otras clases deben cumplir si se implementa dicha interfaz.

Es un contrato donde se define que se va ha realizar; posteriormente en las clases que implementen esta interfaz, se desarrolla la lógica del negocio.
//Persona.php

<?php
namespace Interf;

interface Persona{

public function getDatosPersonales();
public function setDatosPersonales($nombre,$apellido);

}

//Cliente.php
<?php
namespace PooPHP;
use Interf\Persona;

class Cliente implements Persona{

public $nombre;
public $apellido;

public function __construct($nombre,$apellido){
	$this->nombre=$nombre;
	$this->apellido=$apellido;
}

public function getDatosPersonales(){
$datp=["nombre"=>$this->nombre,
       "apellido"=>$this->apellido
];	
	echo json_encode($datp);
}

public function setDatosPersonales($nombre,$apellido){
	$this->nombre=$nombre;
	$this->apellido=$apellido;
}

}

//poo.php

<?php
echo ‘<!DOCTYPE html>
<html lang=“es”>
<head>
<meta charset=“UTF-8”/>
<title>POO CON PHP</title>
</head>
<body>’;

require_once DIR."/vendor/autoload.php";
use \PooPHP\Cliente;

$cliente=new Cliente(“Juan Esteban”,“Moreno Grajales”);
$cliente->getDatosPersonales();

echo ‘</body>
</html>’;

Una interfaz es básicamente un esqueleto para definir la forma y el comportamiento esperado de nuestras clases, toda clase que implemente dicha interfaz deberá desarrollar sus métodos y atributos

Excelente

Considero que las interfaces son importantes ya que de esta manera “amarramos” todas nuestras pruebas unitarias.

Algo similar ocurre con los traits, pero esos traits se pueden implementar en cualquier clase que las use, con la diferencia que allí se puede definir los bloques de código que se van reusar.

Interfaces

Se desarrolla y se implementa en una clase, al ser implementada estamos obligados a desarrollar todos los métodos que la interfaz define.

Se puede considerar como:

• El que se va hacer, se define en una interface.
• El como se va hacer en una implementación se define en una clase.

Podemos resumir que una interface es un contracto donde nos indica como debemos desarrollar los métodos que se tienen.

En la interface definimos los diferentes métodos que quiero que sean obligatorios dentro de una clase.

<?php
    // Contractamos
    interface Person
    {
        public function getName();
    }

    class Admin implements Person
    {
        public $name;

        public function __construct($name)
        {
            $this->name = $name;
        }

        public function getName()
        {
            return $this->name;
        }
    }


    $admin = new Admin('Lynda');
    echo $admin->getName();
?>