接口隔离原则（Interface Segregation Principle，ISP）

接口隔离原则：

1.使用多个专门的接口比使用单一的总接口要好。
2.一个类对另外一个类的依赖性应当是建立在最小的接口上的。
3.一个接口代表一个角色，不应当将不同的角色都交给一个接口。没有关系的接口合并在一起，形成一个臃肿的大接口，这是对角色和接口的污染。
4.“不应该强迫客户依赖于它们不用的方法。接口属于客户，不属于它所在的类层次结构。”这个说得很明白了，再通俗点说，不要强迫客户使用它们不用的方法，如果强迫用户使用它们不使用的方法，那么这些客户就会面临由于这些不使用的方法的改变所带来的改变。

interface I {
    public void method1();

    public void method2();

    public void method3();

    public void method4();

    public void method5();
}

class 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 {
    @Override
    public void method1() {
        System.out.println("类B实现接口I的方法1");
    }

    @Override
    public void method2() {
        System.out.println("类B实现接口I的方法2");
    }

    @Override
    public void method3() {
        System.out.println("类B实现接口I的方法3");
    }

    //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，
    //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
    @Override
    public void method4() {
    }

    @Override
    public void method5() {
    }
}

class C {
    public void depend1(I i) {
        i.method1();
    }

    public void depend2(I i) {
        i.method4();
    }

    public void depend3(I i) {
        i.method5();
    }
}

class D implements I {
    @Override
    public void method1() {
        System.out.println("类D实现接口I的方法1");
    }

    //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，
    //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
    @Override
    public void method2() {
    }

    @Override
    public void method3() {
    }

    @Override
    public void method4() {
        System.out.println("类D实现接口I的方法4");
    }

    @Override
    public void method5() {
        System.out.println("类D实现接口I的方法5");
    }
}

class Client {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend2(new D());
        c.depend3(new D());
    }
}

interface I1 {
    public void method1();
}

interface I2 {
    public void method2();

    public void method3();
}

interface I3 {
    public void method4();

    public void method5();
}

class A {
    public void depend1(I1 i) {
        i.method1();
    }

    public void depend2(I2 i) {
        i.method2();
    }

    public void depend3(I2 i) {
        i.method3();
    }
}

class B implements I1, I2 {
    @Override
    public void method1() {
        System.out.println("类B实现接口I1的方法1");
    }

    @Override
    public void method2() {
        System.out.println("类B实现接口I2的方法2");
    }

    @Override
    public void method3() {
        System.out.println("类B实现接口I2的方法3");
    }
}

class C {
    public void depend1(I1 i) {
        i.method1();
    }

    public void depend2(I3 i) {
        i.method4();
    }

    public void depend3(I3 i) {
        i.method5();
    }
}

class D implements I1, I3 {
    @Override
    public void method1() {
        System.out.println("类D实现接口I1的方法1");
    }

    @Override
    public void method4() {
        System.out.println("类D实现接口I3的方法4");
    }

    @Override
    public void method5() {
        System.out.println("类D实现接口I3的方法5");
    }
}