Princípio da segregação da interface, o princípio do isolamento da interface do ISP defende que o uso de várias interfaces dedicadas é melhor do que usar uma única interface total.
A dependência de uma classe em outra classe deve ser estabelecida na menor interface.
Uma interface representa uma função e funções diferentes não devem ser entregues a uma interface. As interfaces não relacionadas são mescladas para formar uma interface grande inchada, que é uma poluição para o papel e a interface.
"Os clientes não devem ser forçados a confiar nos métodos que não usam. As interfaces pertencem aos clientes, não à hierarquia de classes em que estão". Isso é muito claro. Em termos simples, não force os clientes a usar métodos que eles não usam. Se os usuários forem forçados a usar métodos que não usam, esses clientes enfrentarão alterações causadas por alterações nesses métodos que não usam.
No caso de uso, forneça os métodos necessários para o chamador e bloqueie métodos desnecessários. Ele atende ao princípio do isolamento da interface. Por exemplo, no sistema de comércio eletrônico, existem três lugares que serão usados na categoria de ordem.
De acordo com o princípio do isolamento da interface (ISP), a dependência de uma classe em outra classe deve ser estabelecida na menor interface.
Ou seja, para um portal, ele só pode confiar em uma interface com um método de consulta.
A estrutura UML é a seguinte:
Vejamos um exemplo de escrita de interface Java que ignora o princípio do isolamento da interface:
interface i {public void métod1 (); Public void Method2 (); Public void Method3 (); Public Void Method4 (); Public void Method5 (); } classe A {public void Depend1 (i i) {i.method1 (); } public void depend2 (i i) {i.method2 (); } public void Depend3 (i i) {i.method3 (); } } class B implements I{ public void method1() { System.out.println("Method1" to implement interface I"); } public void method2() { System.out.println("Method 2 of Class B implements Interface I"); } public void method3() { System.out.println("Method 3 of Class B implements Interface I"); } //For class B, O método4 e o método5 não são necessários, mas como existem esses dois métodos na interface A, // no processo de implementação, mesmo que o corpo do método desses dois métodos esteja vazio, esses dois métodos devem ser implementados. I.Method4 (); } // Para Classe D, Method2 e Method3 não são necessários, mas porque existem esses dois métodos na interface A, //, mesmo que o corpo do método desses dois métodos esteja vazio durante o processo de implementação, esses dois métodos que não têm efeito devem ser implementados. public void method2 () {} public void method3 () {} public void method4 () {System.out.println ("Método 4 da classe D implementa a interface I"); } public void method5 () {System.out.println ("Método 5 da classe D implementos interface I"); }} public class cliente {public static void main (string [] args) {a a = novo a (); A.Depend1 (novo B ()); A.Depend2 (novo B ()); A.Depend3 (novo B ()); C c = novo c (); c.Depend1 (novo d ()); c.Depend2 (novo d ()); c.Depend3 (novo d ()); }} Pode -se observar que, se a interface estiver muito inchada, desde que os métodos apareçam na interface, independentemente de serem úteis para as classes que dependem dela, esses métodos devem ser implementados na classe de implementação. Obviamente, este não é um bom design. Se esse design for modificado para cumprir o princípio do isolamento da interface, interface, devo ser dividido. Aqui dividimos a interface original I em três interfaces. O design dividido é mostrado na figura abaixo:
Como sempre, poste o código do programa para referência para amigos que não estão familiarizados com o diagrama de classe:
interface i1 {public void method1 (); } interface i2 {public void method2 (); Public void Method3 (); } interface i3 {public void method4 (); Public void Method5 (); } classe A {public void Depend1 (i1 i) {i.method1 (); } public void depend2 (i2 i) {i.method2 (); } public void Depend3 (i2 i) {i.method3 (); }} classe B implementa i1, i2 {public void method1 () {System.out.println ("Método 1 da classe B implementa a interface i1"); } public void method2 () {System.out.println ("Método 2 da classe B implementos interface i2"); } public void method3 () {System.out.println ("Método 3 da classe B implementos interface i2"); }} classe C {public void Depend1 (i1 i) {i.method1 (); } public void depend2 (i3 i) {i.method4 (); } public void Depend3 (i3 i) {i.method5 (); }} classe D implementa i1, i3 {public void method1 () {System.out.println ("Método 1 da classe D implementa a interface i1"); } public void method4 () {System.out.println ("Método 4 da classe D implementos interface i3"); } public void method5 () {System.out.println ("Método 5 da classe D implementos interface i3"); }} O significado do princípio do isolamento da interface é: estabelecer uma única interface, não estabeleça uma interface enorme e inchada, tente refinar a interface e tente menos métodos na interface. Em outras palavras, precisamos estabelecer uma interface dedicada para cada classe, em vez de tentar estabelecer uma interface enorme para todas as classes que dependem dela para chamar. Neste exemplo, o princípio do isolamento da interface é adotado ao alterar uma interface enorme para três interfaces dedicadas. Na programação, confiar em várias interfaces dedicadas é mais flexível do que confiar em uma interface abrangente. As interfaces são "contratos" definidos para configurações externas durante o design. Ao definir várias interfaces, a propagação de alterações externas pode ser evitada e a flexibilidade e manutenção do sistema podem ser melhoradas.
Falando nisso, muitas pessoas sentirão que o princípio do isolamento da interface é muito semelhante ao princípio anterior de responsabilidade, mas não é. Primeiro, o princípio da responsabilidade única se concentra nas responsabilidades; Enquanto o princípio do isolamento da interface se concentra no isolamento da dependência da interface. Segundo, o princípio da responsabilidade única é principalmente as classes de restrição, seguidas de interfaces e métodos, que são destinados à implementação e detalhes do programa; Enquanto o princípio do isolamento da interface restringe principalmente interfaces de interface, visam principalmente a abstração e visam a construção da estrutura geral do programa.
Ao usar o princípio do isolamento da interface para restringir as interfaces, os seguintes pontos devem receber atenção a:
A interface deve ser o mais pequena possível, mas deve ser limitada. Refinar a interface pode melhorar a flexibilidade da programação é um fato de que não é lucrativa, mas se for muito pequena, causará muitas interfaces e complicará o design. Portanto, deve ser moderado.
Serviços personalizados para classes que dependem das interfaces, apenas os métodos que ele precisa ser exposto à classe chamada e os métodos de que não precisa estão ocultos. Somente concentrando -se no fornecimento de serviços personalizados para um módulo, você pode estabelecer um relacionamento mínimo de dependência.
Melhore a coesão e reduza as interações externas. Use a menor quantidade de interface para realizar mais coisas.
Ao usar o princípio do isolamento da interface, ele deve ser moderado. Não é bom ter um design de interface muito grande ou muito pequeno. Ao projetar interfaces, apenas gastando mais tempo pensando e planejando esse princípio pode ser praticado com precisão.