Interface Segregation Principle

Curso de Patrones de Diseño y Buenas Prácticas en PHP

Contenido del curso

Comprender los objetivos y pre-requisitos del curso

Aprender a escribir código legible

Aprender a escribir código mantenible

Escribir código libre de vicios

Conocer los principios SOLID

Conocer los conceptos de Patrones de diseño y su aplicación

Comprender las nociones de testing automatizado

Incorporar habilidades para el trabajo en equipo

Reforzar lo aprendido

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:004:26

Recursos

Resumen

El Interface Segregation Principle establece que los clientes de un programa sólo deberían conocer de éste los métodos que realmente usan.

Interface Segregation Principle

Curso de Patrones de Diseño y Buenas Prácticas en PHP

Clase 14 de 26

Clase 14 / 26

Comentarios (52)52 comentarios

Bernardo Ayala Montezuma

Hace 7 años

El principio de segregación de interfaces nos dice un poco como estructurar nuestras interfaces de modo que cuando una clase implementa una interface, no se le exija implementar métodos que no necesita.

Bernardo Aguayo Ortega

Hace 6 años

Gracias hermano, mucho más claro

Reinaldo Mendoza

Hace 6 años

Muy buena tu abstracción del concepto

Carlos Eduardo Gomez García

Hace 6 años

De una forma más simplificada:

"Si una clase implementa una interfaz, y la interfaz le obliga definir un método que no necesita, entonces probablemente tu clase no está implementando la interfaz correcta"

Y una solución a ello puede ser:

Divide esa interfaz en interfaces más específicas, y en tus clases solo implementa las interfaces que necesites.

Faber Edison Ordoñez Alvarado

Hace 6 años

Gran aporte, mucho mas claro y simplificado

Jose Orlando Parra Soto

Hace 6 años

siempre acudo a tus comentarios por que son de gran ayuda, muchas gracias

Juan Pena Verdú

Hace 7 años

El principio de segregación de la interfaz (ISP, por sus siglas del inglés «Interface Segregation Principle») establece que los clientes de un programa dado sólo deberían conocer de éste aquellos métodos que realmente usan, y no aquellos que no necesitan usar.

Marco Alexander Mateo Mateo

Hace 7 años

¡Muchas gracias! :D

Usuario anónimo

User

Hace 7 años

¡Genial!

María Sierra

Hace 6 años

Resumen:

En palabra simples el principio de segregación de interfaz nos indica que no debemos de dar más de la información necesaria a los módulos que van a funcionar.

Daniel Ponce

Hace 6 años

PRINCIPIO DE SEGRACION DE INTERFAZ

Un cliente nunca debería verse obligado a depender de métodos que no utilice.
O un cliente nunca debería depender de nada más que del método al que está llamando.
Cambiar un método en una clase no debería afectar a las clases que no dependen de él.
Reemplace las interfaces con muchas interfaces pequeñas y específicas.

Luis Manuel Brito Romero

Hace 7 años

Ahhh ahora si entendí mucho mejor lo que es una interfaz. Excelente!

Daniel Meza

Hace 7 años

La interfaz viene a ser un contrato. Por lo que todos los métodos que la interfaz contenga, la clase que le implemente debe usarlos a fuerza. Por eso es que hay que optimizarlo de la manera que lo especifica este principio. Así no se usan métodos que estén de más.

Usuario anónimo

User

Hace 7 años

Ayudan mucho a la legibilidad.

GARCIA CAMARENA EZEQUIEL

Hace 7 años

Nota: este principio dice como estructurar las interfaces. De modo que cuando una clase implementa una interface no se le exija implementar métodos que no necesita o no son propios.

Bernardo Aguayo Ortega

Hace 6 años

así de simple

Jose Manuel del Villar Soriano

Hace 7 años

Hablan de buenas prácticas, pero realmente creo que en sus ejemplos les faltó un mejor nombre para sus variables. Es cierto que el ejemplo es fácilmente entendible, pero si solamente se viera la variable v en otra parte del código no se sabría fácilmente que es un vehículo.

Luis Abdel Rangel Castro

Hace 7 años

Hay que ser finos!!!

Jesus Gaviria Rubio

Hace 7 años

El analisis antes de empezar a echar codigo

Sergio Estrella

Profesor

Hace 6 años

Quedó super claro el principio con éste ejemplo! :D

Muñoz Ortiz Leonel

Hace 7 años

Como se veria el diagrama de clases del ejemplo ?

SEBASTIAN SALAZAR

Hace 6 años

Adriana Joali Rebollar Cid

Hace 5 años

encontré este blog que lo explica con código super fácil https://enmilocalfunciona.io/principios-solid/

Luis Fernando Zarazua Aguilar

Hace 6 años

<?php
    //Ejemplo no aplicando el principio de segregación de interfaces.
    interface Workable 
    {
        public function canCode();//Función de más.
        public function code();//Función reemplazable en otra interfaz.
        public function test();//Función reemplazable en otra interfaz.
    }

    class Programmer implements Workable //Implementa a Workable.
    {
        public function canCode()
        {
            return true;
        }

        public function code()
        {
            return 'coding';
        }

        public function test()
        {
            return 'testing in localhost';
        }
    }

    class Tester implements Workable
    {
        //La función canCode sirve para describir al objeto lo cual puede hacerse mediante una interfaz.
        public function canCode()
        {
            return false;
        }
        //La función code no tiene ninguna funcionalidad
        public function code()
        {
            throw new Exception("Opps! I can\'t code");
        }

        public function test()
        {
            return 'testing in test server';
        }
    }

    class ProjectManagment
    {
        public function processCode(Workable $member)
        {
            if ($member->canCode()) {//Primero debe verficar un método repetitivo (se declara en cada workable) antes de poderlo ejecutar. 
                echo $member->code();//
            }
        }
    }
    
    //Ejemplo aplicando el principio de segregación de interfaces.
    interface CodeAble 
    {
        public function code();//Declaración de una sola función para codificar.
    }

    interface testAble 
    {
        public function test();//Declaración de una sola función para programar.
    }

    class ProgrammerI implements CodeAble, TestAble
    {
        public function code()
        {
            return 'coding';
        }

        public function test()
        {
            return 'testing in localhost';
        }
    }
    
    class TesterI implements CodeAble
    {
        public function code()
        {
            return 'coding';
        }
    }

    class ProjectManagmentI
    {
        public function processCode(CodeAble $member)//En el mismo tipo se verifica si soporta procesar código.
        {
                echo $member->code();
        }
    }

    $testerguy = new Tester();
    $programerguy = new Programmer();
    $manager = new ProjectManagment();
    $manager->processCode($testerguy);
    $manager->processCode($programerguy);
    
    $testerguyI = new TesterI();
    $programerguyI = new ProgrammerI();
    $managerI = new ProjectManagmentI();

    $managerI->processCode($testerguyI);
    $managerI->processCode($programerguyI);

?>

Jose Efrey Rodriguez

Hace 6 años

gran explicación ....

Fernando Hernandez

Hace 7 años

Una clase puede implementar tantas interfaces como sea necesario ....

sebastian miranda hernandez

Hace 6 años

Aporte: Aplicando el Principio Segregación de Interface cada cliente solo tiene acceso a lo que necesita. También conseguimos que los detalles dependan de las abstracciones y no las abstracciones de los detalles que es muy importante para que las necesidades las marque el cliente.

Fernando Mejia

Hace 7 años

Muy bien es un ejemplo claro y etendible!

Mario Alejandro Macias Ortiz

Hace 7 años

Es decir solo valida lo validable, No lo obvio.

Carlos Andres Castañeda Osorio

Hace 7 años

Hacer interfaces más específicas que permitan crear los métodos estrictamente necesarios pensando en todas aquellas las clases que los pueden implementar.

Elisa Zamarron Muñoz

Hace 7 años

Me gustó tu definición, además este video me pareció mejor explicado que los dos anteriores.

<?php
    //Ejemplo no aplicando el principio de segregación de interfaces.
    interface Workable 
    {
        public function canCode();//Función de más.
        public function code();//Función reemplazable en otra interfaz.
        public function test();//Función reemplazable en otra interfaz.
    }

    class Programmer implements Workable //Implementa a Workable.
    {
        public function canCode()
        {
            return true;
        }

        public function code()
        {
            return 'coding';
        }

        public function test()
        {
            return 'testing in localhost';
        }
    }

    class Tester implements Workable
    {
        //La función canCode sirve para describir al objeto lo cual puede hacerse mediante una interfaz.
        public function canCode()
        {
            return false;
        }
        //La función code no tiene ninguna funcionalidad
        public function code()
        {
            throw new Exception("Opps! I can\'t code");
        }

        public function test()
        {
            return 'testing in test server';
        }
    }

    class ProjectManagment
    {
        public function processCode(Workable $member)
        {
            if ($member->canCode()) {//Primero debe verficar un método repetitivo (se declara en cada workable) antes de poderlo ejecutar. 
                echo $member->code();//
            }
        }
    }
    
    //Ejemplo aplicando el principio de segregación de interfaces.
    interface CodeAble 
    {
        public function code();//Declaración de una sola función para codificar.
    }

    interface testAble 
    {
        public function test();//Declaración de una sola función para programar.
    }

    class ProgrammerI implements CodeAble, TestAble
    {
        public function code()
        {
            return 'coding';
        }

        public function test()
        {
            return 'testing in localhost';
        }
    }
    
    class TesterI implements CodeAble
    {
        public function code()
        {
            return 'coding';
        }
    }

    class ProjectManagmentI
    {
        public function processCode(CodeAble $member)//En el mismo tipo se verifica si soporta procesar código.
        {
                echo $member->code();
        }
    }

    $testerguy = new Tester();
    $programerguy = new Programmer();
    $manager = new ProjectManagment();
    $manager->processCode($testerguy);
    $manager->processCode($programerguy);
    
    $testerguyI = new TesterI();
    $programerguyI = new ProgrammerI();
    $managerI = new ProjectManagmentI();

    $managerI->processCode($testerguyI);
    $managerI->processCode($programerguyI);

?>

Comprender los objetivos y pre-requisitos del curso

Todo lo que aprenderás sobre buenas prácticas para escribir código

¿A quién beneficia contar con código bien escrito?

Ejes que hacen a la calidad del código

Aprender a escribir código legible

Código prolijo

Identificadores mnemotécnicos, específicos y precisos

Aprender a escribir código mantenible

Código modular

Código reutilizable

Código organizado

Escribir código libre de vicios

Evitar el hardcoding

Evitar efectos colaterales

Conocer los principios SOLID

Principios SOLID: Single Responsibility Principle

Open/Closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

Conocer los conceptos de Patrones de diseño y su aplicación

Patrones de diseño: Singleton

Factory

Command

Comprender las nociones de testing automatizado

Introducción al Testing Automatizado

Armado del entorno de pruebas en PHP

Test Driven Development

Incorporar habilidades para el trabajo en equipo

Pull requests

Documentación

Reforzar lo aprendido

A quién beneficia el código bien escrito

Aplicar lo aprendido: Libro de visitas

Conclusiones

Resumen

Interface Segregation Principle