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.
Fundamentos
Lo que aprenderás sobre POO en PHP
Deuda técnica
Code smell
Código espagueti
Inclusión de archivos
Programación orientada a objetos
Introducción a clases y objetos
Abstracción
Alcance o Encapsulamiento
Modularidad
Polimorfismo
Polimorfismo: interfaz
Herencia
Interfaces
Resumen
Proyecto en PHP
Iniciando nuestro proyecto: PHPUnit y clases heredadas
Continuando nuestro proyecto
Revisión del proyecto
Reto - Ejercicio
Conclusión - Frameworks PHP
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Convierte tus certificados en títulos universitarios en USA
Antes: $249
Paga en 4 cuotas sin intereses
Termina en:
Profesor Italo Morales F
Aportes 34
Preguntas 5
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.
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;
}
}
De momento una interfaz es un contrato que debemos cumplir al momento de implementar en las diferentes clases.
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 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.
Tal vez sería bueno un curso un poco más práctico, orientado a la construcción de un proyecto tipo CRUD o similar donde se nos muestre las diferentes maneras en la que podemos construir un proyecto con POO.
Cuando una clase hereda o implementa la interface se esta comprometiendo a prooveer una implementacion de esos metodos.
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???
Definicion de una interfaz con el ejemplo.
🍃 Las interfaces en programación orientada a objetos son como un contrato que especifica un conjunto de métodos que una clase debe implementar. En otras palabras, las interfaces definen una serie de comportamientos que una clase debe seguir. Esto permite que las clases sean intercambiables y facilita la comunicación entre diferentes partes de un programa.
En PHP, las interfaces se definen con la palabra clave interface
. Una interfaz no puede tener propiedades, solo métodos. Los métodos de una interfaz no tienen cuerpo, es decir, no tienen código dentro de ellos, solo especifican la firma del método (nombre, parámetros y tipo de retorno).
Un ejemplo de interfaz en PHP podría ser el siguiente:
interface iUser {
public function login($username, $password);
public function logout();
}
class User implements iUser {
public function login($username, $password) {
// Lógica para iniciar sesión
}
public function logout() {
// Lógica para cerrar sesión
}
}
En este ejemplo, la interfaz iUser
especifica dos métodos que cualquier clase que implemente la interfaz debe tener: login()
y logout()
. La clase User
implementa la interfaz iUser
y define los métodos login()
y logout()
de acuerdo con la firma especificada en la interfaz.
El uso de interfaces permite que las clases se comuniquen entre sí de manera más flexible. Por ejemplo, supongamos que hay una clase Authentication
que necesita trabajar con cualquier objeto que tenga los métodos login()
y logout()
. En lugar de hacer que Authentication
trabaje directamente con la clase User
, se puede hacer que trabaje con cualquier objeto que implemente la interfaz iUser
. Esto significa que si se crea otra clase que también implemente la interfaz iUser
, Authentication
puede trabajar con esa clase sin necesidad de cambiar su código.
En resumen, las interfaces son una forma de definir comportamientos que una clase debe implementar y permiten que las clases sean intercambiables y se comuniquen entre sí de manera más flexible.
Una interfaz se desarrolla y se implementa en una clase, al implementar nosotros estamos obligados a desarrollar todos los métodos que la interfaz define.
Una interfaz es un contrato.
En este caso la interfaz muestra de manera sencilla que sirve como contrato.
Una interfaz es un contrato que debemos cumpliar a la hora de querer utilizarla en otra clase…
Resumen de la clase:
<?php
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();
?>
Los temas avanzados con interfaces se ven en los patrones de diseño, por ahora entiéndanlo como un contrato solamente.
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"
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;
}
}
<?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.
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:
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();
?>
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?