设计模式七大原则02---接口隔离原则

接口隔离原则应该遵循客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上,下面我们可以通过具体的案例来演示

1、UML 图如下

2、方式一、普通实现

public class DesignPatternPrinciple {
    public static void main(String[] args) {
        A a = new A();
        a.depend(new B());

        C c = new C();
        c.depend(new D());
    }
}

interface MyInterface {
    public abstract void operation1();
    public abstract void operation2();
    public abstract void operation3();
    public abstract void operation4();
    public abstract void operation5();
}

class B implements MyInterface {
    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1 方法");
    }
    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2 方法");
    }
    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3 方法");
    }
    @Override
    public void operation4() {
        System.out.println("B 实现了 operation4 方法");
    }
    @Override
    public void operation5() {
        System.out.println("B 实现了 operation5 方法");
    }
}

class A {
    public void depend(MyInterface myInterface) {
        myInterface.operation1();
        myInterface.operation2();
        myInterface.operation3();
    }
}

class D implements MyInterface {
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1 方法");
    }
    @Override
    public void operation2() {
        System.out.println("D 实现了 operation2 方法");
    }
    @Override
    public void operation3() {
        System.out.println("D 实现了 operation3 方法");
    }
    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4 方法");
    }
    @Override
    public void operation5() {
        System.out.println("D 实现了 operation5 方法");
    }
}

class C {
    public void depend(MyInterface myInterface) {
        myInterface.operation1();
        myInterface.operation4();
        myInterface.operation5();
    }
}

测试结果

通过方式一虽然实现了我们的需求,但是这里存在一个问题,类 A 通过接口 MyInterface 依赖类 B,它只需要实现的方法是 1、2、3,但是 类 B 作为接口 MyInterface 的实现类,它就必须要实现接口里的所有方法,同理,类 C 通过接口 MyInterface 依赖类 D,它只需要实现的方法是 1、4、5,但是类 D 作为接口 MyInterface 的实现类它也必须要实现接口 MyInterface 里面的 1、2、3、4、5 这些抽象方法,按照我们正常的思维逻辑,既然是我不需要的方法,那么我就没有必要去实现它

针对上述的问题按隔离原则应当这样处理

将接口 MyInterface 拆分为独立的几个接口(这里我们拆分成 3 个接口),类 A 和类 C 分别与它们需要的接口建立依赖关系.也就是采用接口隔离原则

3、方式二、使用接口隔离原则改进

public class DesignPatternPrinciple {
    public static void main(String[] args) {
        A a = new A();
        a.depend01(new B());
        a.depend02(new B());

        C c = new C();
        c.depend01(new D());
        c.depend02(new D());

    }
}

interface MyInterface01 {
    public abstract void operation1();
}

interface MyInterface02 {
    public abstract void operation2();
    public abstract void operation3();
}

interface MyInterface03 {
    public abstract void operation4();
    public abstract void operation5();
}

class B implements MyInterface01,MyInterface02 {
    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1 方法");
    }
    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2 方法");
    }
    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3 方法");
    }
}

class A {
    public void depend01(MyInterface01 myInterface01) {
        myInterface01.operation1();
    }
    public void depend02(MyInterface02 myInterface02) {
        myInterface02.operation2();
        myInterface02.operation3();
    }
}

class D implements MyInterface01,MyInterface03 {
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1 方法");
    }
    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4 方法");
    }
    @Override
    public void operation5() {
        System.out.println("D 实现了 operation5 方法");
    }
}

class C {
    public void depend01(MyInterface01 myInterface01) {
        myInterface01.operation1();
    }
    public void depend02(MyInterface03 myInterface03) {
        myInterface03.operation4();
        myInterface03.operation5();
    }
}

利用接口隔离原则进行改进之后,类 B 和类 D 只需要实现各自实现的方法就可以,不需要实现接口里面的所有方法,这样就满足了一个类对另一个类的依赖建立在最小接口上的原则