接口隔离原则

客户端不应该依赖他不需要的接口，即一个类对另一个类的依赖应该建立在最小接口上

package com.cedric.segregation;
// 没有使用接口隔离原则
/*
客户端不应该依赖他不需要的接口，即一个类对另一个类的依赖应该建立在最小接口上
Interface1接口对于A类和C类来说不是最小最小接口，A类和C类不需要实现多余的方法
隔离原则处理：
将接口Interface1拆分成几个独立接口，A类和C类分别与他们需要的接口建立关系，采用接口隔离原则
 */
public class SegregationDemo01 {
    public static void main(String[] args) {
    }
}
// Interface1接口
interface Interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}
// 实现类B
class B implements Interface1{
    @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");
    }
}
// 实现类D
class D implements Interface1{
    @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 A{ // A类通过接口Interface1 依赖（使用）B类  但是只会用到1，2,3方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface1 i){
        i.operation2();
    }
    public void depend(Interface1 i){
        i.operation3();
    }
}
class C{ // B类通过接口Interface1使用D类   但是只会用到1,4,5方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface1 i){
        i.operation4();
    }
    public void depend5(Interface1 i){
        i.operation5();
    }
}

package com.cedric.segregation;

/*
改进方案：
    采用接口隔离原则，使用最小接口
 */
public class SegregationDemo02 {
    public static void main(String[] args) {
        A1 a1 = new A1();
        a1.depend1(new B1()); // A类通过接口依赖B类
        a1.depend2(new B1());

        C1 c = new C1();
        c.depend1(new D1()); // C类通过接口依赖D类
        c.depend2(new D1());
    }
}

interface Interface01{
    void operation1();
}

interface Interface02{
    void operation2();
    void operation3();
}

interface Interface03{
    void operation4();
    void operation5();
}

class B1 implements Interface01,Interface02{

    @Override
    public void operation1() {
        System.out.println("B1==>operation01");
    }

    @Override
    public void operation2() {
        System.out.println("B1==>operation02");
    }

    @Override
    public void operation3() {
        System.out.println("B1==>operation03");
    }
}

class D1 implements Interface01,Interface03{

    @Override
    public void operation1() {
        System.out.println("D1 ==> operation01");
    }

    @Override
    public void operation4() {
        System.out.println("D1 ==> operation04");
    }

    @Override
    public void operation5() {
        System.out.println("D1 ==> operation05");
    }
}

class A1{
    public void depend1(Interface01 i1){
        i1.operation1();
    }

    public void depend2(Interface02 i2){
        i2.operation2();
        i2.operation3();
    }
}

class C1{
    public void depend1(Interface01 i1){
        i1.operation1();
    }

    public void depend2(Interface03 i3){
        i3.operation4();
        i3.operation5();
    }
}