Principio de segregación de interfaz

El Principio de segregación de interfaz es la siguiente parada en nuestro recorrido por los 5 principios sólidos. Afortunadamente, es bastante fácil de entender. Todo lo que significa es que no se debe obligar a un cliente a implementar una interfaz que nunca usará. Esta es la idea principal del Principio de segregación de interfaz. Al igual que el resto de los cinco patrones de diseño sólidos, el Principio de segregación de interfaz existe para ayudar a desacoplar los módulos dentro del software y hacer que el código sea más fácil de entender, refactorizar y mantener.

Diseño de interfaz

En este punto, sabemos cómo usar una interfaz en nuestros programas. Esto es genial, pero aún podemos encontrar problemas con las interfaces también. Es decir, con el principio de segregación de interfaces, queremos estar seguros de no llenar nuestras interfaces con el fregadero de métodos. Si agregamos demasiados métodos a nuestras interfaces, se vuelven demasiado gordos y comenzamos a perder algunos de los beneficios del sólido que estamos tratando de lograr. Como siempre, echemos un vistazo a algún código para ver a qué nos referimos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php 
 
class Underling {
    public function program()
    {
        return 'Program initech systems to deposit fractions of pennies to private account';
    }
    public function filetps()
    {
        return 'Place cover sheet on TPS report before going out';
    }
    public function collate()
    {
        return 'Collect and combine texts, information, and figures in proper order.';
    }
}
 
class Lumbergh
{
    public function harass(Underling $underling)
    {
        $underling->program();
        $underling->filetps();
        $underling->collate();
    }
}
 
$lumbergh = new Lumbergh;
$lumbergh->harass(new Underling);

Para comenzar, tenemos una Lumberghclase que tiene un harassmétodo que depende de una Underlingfunción. Podemos ver que una Underlingdebe ser capaz de program, filetpsy collate. Hasta ahora todo bien, pensamos. Lumberghes capaz de ayudar a harasslos nuevos subordinados que se cruzan en su camino. Ahora, ¿qué sucede cuando Lumbergh necesita traer algunos consultores a Initech? ¿Cómo se desarrollará eso? Lumbergh debería poder acosar tanto a los subordinados como a los consultores con igual impunidad. Bueno, tal vez podamos configurar una interfaz y hacer que los subordinados y consultores implementen esa interfaz para que Lumbergh pueda acosarlos. Probémoslo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
interface UnderlingInterface {
    public function program();
    public function filetps();
    public function collate();
}
 
class Underling implements UnderlingInterface {
    public function program()
    {
        return 'Program initech systems to deposit fractions of pennies to private account';
    }
    public function filetps()
    {
        return 'Place cover sheet on TPS report before going out';
    }
    public function collate()
    {
        return 'Collect and combine texts, information, and figures in proper order.';
    }
}
 
class Consultant implements UnderlingInterface {
    public function program()
    {
        return 'Outsource task to India';
    }
    
    public function filetps()
    {
        return 'Place cover sheet on TPS report before going out';
    }
}
 
class Lumbergh
{
    public function harass(Underling $underling)
    {
        $underling->program();
        $underling->filetps();
        $underling->collate();
    }
}
 
$lumbergh = new Lumbergh;
$lumbergh->harass(new Consultant);

Tenemos un pequeño problema. Tanto nuestro Underlingcomo las Consultantclases implementan el UnderlingInterface. Los consultores, sin embargo , no cotejan . El problema es que, dado que un Consultor implementa de hecho la Interfaz Underling, y dado que la Interfaz Underling especifica que debemos ser capaces de programar, filetps y cotejar, entonces debemos obligar al Consultor a implementar esta parte de la interfaz que nunca utilizar . Aquí está nuestro nuevo programa actualizado, que funciona, pero viola el Principio de segregación de interfaz (el consultor se ve obligado a implementar el collatemétodo).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?php 
 
interface UnderlingInterface {
    public function program();
    public function filetps();
    public function collate();
}
 
class Underling implements UnderlingInterface {
    public function program()
    {
        return 'Program initech systems to deposit fractions of pennies to private account';
    }
    public function filetps()
    {
        return 'Place cover sheet on TPS report before going out';
    }
    public function collate()
    {
        return 'Collect and combine texts, information, and figures in proper order.';
    }
}
 
class Consultant implements UnderlingInterface {
    public function program()
    {
        return 'Outsource task to India';
    }
    
    public function filetps()
    {
        return 'Place cover sheet on TPS report before going out';
    }
    
    public function collate()
    {
        return null;
    }
}
 
class Lumbergh
{
    protected $underling;
    
    public function __construct(UnderlingInterface $underling)
    {
        $this->underling = $underling;
    }
    public function harass()
    {
        $this->underling->program();
        $this->underling->filetps();
        $this->underling->collate();
    }
}
 
$lumbergh = new Lumbergh(new Consultant);
$lumbergh->harass();

¿Cómo podemos hacerlo mejor?

lumbergh
La solución a un problema de ISP es dividir la interfaz en partes más pequeñas. De hecho, está bien tener una interfaz que solo tenga un método. El problema surge cuando tiene una interfaz que solo tiene método tras método tras método tras método que uno debe implementar. Cuantos más métodos necesiten implementarse, mayor será la posibilidad de efectos de onda en su programa.

En primer lugar, podemos romper nuestra UnderlingInterfaceen una ProgrammableInterface, FiletpsableInterfacey CollatableInterface.

No es ideal

1
2
3
4
5
interface UnderlingInterface {
    public function program();
    public function filetps();
    public function collate();
}

Mejor

1
2
3
4
5
6
7
8
9
10
11
interface ProgrammableInterface{
    public function program();
}
 
interface FiletpsableInterface {
    public function filetps();
}
 
interface CollatableInterface {
    public function collate();
}

Ahora podemos actualizar nuestras clases Underlingy Consultantpara implementar solo las interfaces que necesitan.

La implementación final

Estamos bastante cerca de donde tenemos que estar en este punto, pero tenemos que volver a la Lumberghclase original . Tal como está ahora, la clase Lubergh necesitará hacer una verificación de tipo en la instancia que se pasa. Debe comprobar si se trata de un subordinado o un consultor. La razón de esto es que Lumbergh no puede llamar a un método de intercalación en un tipo de Consultor. ¡Recuerde que se supone que no tenemos que hacer esto! Si necesitamos hacer una verificación de tipo para determinar el comportamiento, es probable que estemos rompiendo algo en el sólido conjunto de principios de diseño. Esto significa que necesitamos una interfaz más. Configuraremos esto para que no importa lo que se pase a la clase Lumbergh, solo se deba realizar un comportamiento, y ese es answer_to_Lumbergh(). Así es como lo hacemos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
<?php
 
interface HarassableInterface {
    public function answer_to_Lumbergh();
}
 
interface UnderlingInterface {
    public function program();
    public function filetps();
    public function collate();
}
 
interface ProgrammableInterface {
    public function program();
}
 
interface FiletpsableInterface {
    public function filetps();
}
 
interface CollatableInterface {
    public function collate();
}
 
class Underling implements ProgrammableInterface, FiletpsableInterface, CollatableInterface, HarassableInterface  {
    public function program()
    {
        echo 'Program initech systems to deposit fractions of pennies to private account <br>';
    }
    public function filetps()
    {
        echo 'Place cover sheet on TPS report before going out <br>';
    }
    public function collate()
    {
        echo 'Collect and combine texts, information, and figures in proper order <br>';
    }
    
    public function answer_to_Lumbergh()
    {
        $this->program();
        $this->filetps();
        $this->collate();
    }
}
 
class Consultant implements ProgrammableInterface, FiletpsableInterface, HarassableInterface {
    public function program()
    {
        echo 'Outsource task to India <br>';
    }
    
    public function filetps()
    {
        echo 'Place cover sheet on TPS report before going out <br>';
    }
    
        public function answer_to_Lumbergh()
    {
        $this->program();
        $this->filetps();
    }
}
 
class Lumbergh
{
    protected $underling;
    
    public function __construct(HarassableInterface $underling)
    {
        $this->underling = $underling;
    }
    public function harass()
    {
        $this->underling->answer_to_Lumbergh();
    }
}

Pasar en un `Underling`da el resultado deseado

1
2
3
4
5
6
$lumbergh = new Lumbergh(new Underling);
$lumbergh->harass();
 
// Program initech systems to deposit fractions of pennies to private account
// Place cover sheet on TPS report before going out
// Collect and combine texts, information, and figures in proper order

Pasar en un `Consultant`también da el resultado deseado

1
2
3
4
5
$lumbergh = new Lumbergh(new Consultant);
$lumbergh->harass();
 
// Outsource task to India
// Place cover sheet on TPS report before going out

Resumen del principio de segregación de interfaces

No obligue a las clases a implementar comportamientos o una interfaz que nunca usarán. ¡Es así de simple!

Header Ads Widget

Principio de segregación de interfaz

Diseño de interfaz

¿Cómo podemos hacerlo mejor?

No es ideal

Mejor

La implementación final

Pasar en un `Underling`da el resultado deseado

Pasar en un `Consultant`también da el resultado deseado

Resumen del principio de segregación de interfaces

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget

Header Ads Widget

Principio de segregación de interfaz

Diseño de interfaz

¿Cómo podemos hacerlo mejor?

No es ideal

Mejor

La implementación final

Pasar en un Underlingda el resultado deseado

Pasar en un Consultanttambién da el resultado deseado

Resumen del principio de segregación de interfaces

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget

Pasar en un `Underling`da el resultado deseado

Pasar en un `Consultant`también da el resultado deseado