A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Interface Segregation Principle

14/26
Recursos

El Interface Segregation Principle establece que los clientes de un programa s贸lo deber铆an conocer de 茅ste los m茅todos que realmente usan.

Aportes 46

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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.

De una forma m谩s simplificada:

鈥淪i 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.

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.

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.

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.

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

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.

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.

Hay que ser finos!!!

El analisis antes de empezar a echar codigo

Qued贸 super claro el principio con 茅ste ejemplo! 馃槃

encontr茅 este blog que lo explica con c贸digo super f谩cil
https://enmilocalfunciona.io/principios-solid/

<?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 cdigo.
        {
                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);

?>

gran explicaci贸n 鈥

Una clase puede implementar tantas interfaces como sea necesario 鈥

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.

Muy bien es un ejemplo claro y etendible!

Es decir solo valida lo validable, No lo obvio.

Hacer interfaces m谩s espec铆ficas que permitan crear los m茅todos estrictamente necesarios pensando en todas aquellas las clases que los pueden implementar.

Buen ejemplo para explicar el concepto.

Entonces el Interface Segregation Principle lo que establece es que 鈥渆specialicemos鈥 a las interfaces para no tener todos los m茅todos en una sola interfaz y as铆 evitar implementar m茅todos innecesariemente en clases que no los necesiten.

Creo que eso es lo que entend铆鈥

  • No obligar a la clase a implementar m茅todos que no necesita.
  • Mantener interfaces espec铆ficas.
  • Usar en composici贸n cuando sea necesario.

Les dejo un aporte de principios solid con ejemplos en laravel https://www.laraveltip.com/guia-definitiva-de-principios-solid-explicados-con-laravel/

Encontre esta imagen que describe lo que es este principio Lol

en varios lenguajes de programaci贸n se usa la palabra reservada Interface, para crear interfaces, en pyhton es diferente鈥ara el que este interesado aca hay un post en donde se indica como hacerlo
interfaces en python

Principio de Segregaci贸n de la Interfaz
_鈥淢ake fine grained interfaces that are client specific.鈥
_

  • En el cuarto principio de SOLID, el t铆o Bob sugiere: 鈥淗az interfaces que sean espec铆ficas para un tipo de cliente鈥, es decir, para una finalidad concreta.

  • En este sentido, seg煤n el Interface Segregation Principle (ISP), es preferible contar con muchas interfaces que definan pocos m茅todos que tener una interface forzada a implementar muchos m茅todos a los que no dar谩 uso.
    Fuente: https://bit.ly/3hj3Amj

鈥揢na clase puede implementar tantas interfaces como sean necesarias鈥

馃槙 ??

Wow!!!

Ok de aqui lo que entendi que a la hora de implementar interfaces estas deben ser un poco mas epecificas en que los metosos a implementar realmente sean necesarios en esta clase en caso contrario si existe un metodo que no tenga q evaluarse en la.clase a implementar se debe partir en dos para implementar mwtodos en la ckase que tengan sentido

NOTA: interface segregation principle.,
Los clientes de un programa solo deberian de conocer de este los metodos que realmente usan.

Mantener interfaces finas y usar en composicion cuando sea necesario

Es mejor tener muchas interfaces con m茅todos espec铆ficos que pocas interfaces con muchos m茅todos.

Excelente ejemplo!

SOLID: Interface Segregation Principle
Establece que los clientes de un programa solo deberian conocer de 茅ste los metodos que realmente usan

Nos dice como implementar una interface para que cuando una clase la implemente no se le exija implementar metodos que no conoce

B谩sicamente este principio es usar lo que se necesita y no incluir funciones, procesos, entre otros que son innecesarios. 馃

La segregaci贸n de interfaces me recuerda al divide y vencer谩s.

Este principio me ha parecido mucho m谩s interesante que los anteriores.

Perfecta explicaci贸n. Gracias

Ejercicio B

/* Open/Closed Principle */
    
    interface Member 
    {
        public function process();
    }

    class Programmer implements Member
    {
        private function code()
        {
            return 'coding';
        }
        public function process()
        {
            $this->code();
        }
    }
    class Tester implements Member
    {
        private function test()
        {
            return 'testing';
        }
        public function process()
        {
            $this->test();
        }
    }
    class ProjectManagement
    {
        public function process(Member $member)
        {
            $member->process();
            throw new Exception('Invalid input member');
        }
    }

Mi aporte al ejercicio A

/* Single Responsibility Principle */

    class Order 
    {
        public function load(){/*...*/}
        public function save(){/*...*/}
        public function update(){/*...*/}
        public function delete(){/*...*/}
    }

    class OrderDetails
    {
        public function getItems(){/*...*/}
        public function getItemCount(){/*...*/}
        public function addItem($item){/*...*/}
        public function deleteItem($item){/*...*/}
        public function calculateTotalSum(){/*...*/}
    }

    class OrderShow
    {
        public function printOrder(){/*...*/}
        public function showOrder(){/*...*/}
    }

https://architectcoders.com/wp-content/uploads/2019/08/principios-solid-devexperto.pdf

Conclusi贸n:
鈥淓l principio de segregaci贸n de interfaces nos ayuda a no obligar a ninguna clase a
implementar m茅todos que no utiliza. Esto nos evitar谩 problemas que nos pueden
llevar a errores inesperados y a dependencias no deseadas. Adem谩s nos ayuda a
reutilizar c贸digo de forma m谩s inteligente鈥

En el minuto 3:08 dice: 鈥淟o importante aqu铆 es recordar que una clase puede implementar tantas interfaces como sea necesario, esta es la clave de este principio.鈥

Interface Segregation Principle

Los clientes de un programa dado solo deberian conocer de este aquellos metodos que realmente usan.

Entend铆 el principio de interfaces con el ejemplo, muy claro el tema.