接口隔离原则

定义

接口隔离原则是指，一个类不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
意思大致是指，一个类不需要某个接口中的全部方法，就不要依赖这个接口，而去依赖能满足该类并方法最少的接口。总之就是拆复杂接口。

示例

反例

//接口隔离原则  示例1
//类A通过接口interface1依赖类B，调用B的1，2，3方法
//类C通过接口interface1依赖类D，调用D的1，4，5方法
//具体依赖关系可查看对应的uml类图
//示例1违背了接口隔离原则

/*
* 上方描述的关系中，如果按照接口隔离原则应该这样处理
* 将接口interface1拆分为几个独立的接口，类A与类C分别与他们需要的接口建立依赖关系，也就是使用接口隔离原则。
* */

public class InterfaceSeperatePrinciple1 {
    public static void main(String[] args) {

    }
}
interface interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}



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");
    }
}

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{
    public void depend1(interface1 b){
        b.operation1();
    }
    public void depend2(interface1 b){
        b.operation2();
    }
    public void depend3(interface1 b){
        b.operation3();
    }
        }
class C{

    public void depend1(interface1 d){
        d.operation1();
    }
    public void depend4(interface1 d){
        d.operation4();
    }
    public void depend5(interface1 d){
        d.operation5();
    }
}

正例

//接口隔离原则示例2
//将接口interface2拆分为3个接口
//关系仍然为类A通过interface2依赖B，类C通过interface2依赖D
//本类实现了接口隔离原则

/*
* 接口隔离原则的目的
* 接口隔离原则是为了约束接口，降低类对接口的依赖
*
* 1.将复杂的接口拆分为多个粒度小的接口，是为了应对外来变更，提高系统的灵活性及可维护性
* 2.接口隔离原则提高了系统的内聚性，减少了对外交互，降低了系统的耦合性
* 3.接口粒度大小定义合理，能够保证系统的稳定性，粒度过小，会使接口数量过多，设计复杂化，粒度过大，灵活性及可维护性变差
* 4.使用多个专门的接口还能体现对象的层次，因为通过接口的继承，可实现对总接口的定义
* 5.能减少项目中的代码冗余，过大的接口中会存放一些不会使用的方法，当实现接口时，会被迫实现这个方法
* 总结好处：
* 灵活，可维护，高内聚，低耦合，减少代码冗余
*
*
*
* */
public class InterfaceSeperatePrinciple2 {
    public static void main(String[] args) {
        A1 a1=new A1();
        a1.depend1(new B1());
        a1.depend2(new B1());
        a1.depend3(new B1());
        C1 c1=new C1();
        c1.depend1(new D1());
        c1.depend4(new D1());
        c1.depend5(new D1());
    }
}
interface interface2{
    void operation1();
}
interface interface3{
    void operation2();
    void operation3();
}
interface interface4{
    void operation4();
    void operation5();
}
class B1 implements interface2,interface3{

    @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 D1 implements interface2,interface4{

    @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 A1{
    public void depend1(interface2 i){
        i.operation1();
    }
    public void depend2(interface3 i){
        i.operation2();
    }
    public void depend3(interface3 i){
        i.operation3();
    }
}
class C1{
    public void depend1(interface2 i){
        i.operation1();
    }
    public void depend4(interface4 i){
        i.operation4();
    }
    public void depend5(interface4 i){
        i.operation5();
    }
}

接口隔离原则总结

接口隔离原则是为了约束接口，降低类对接口的依赖。
接口隔离原则的优点：
1）灵活性，可维护性增强
2）高内聚，低耦合
3）减少代码冗余（减少了方法的实现）
4）体现对象层次

标签：原则,void,System,接口,接口隔离,println,public,out
来源： https://www.cnblogs.com/planted/p/15831424.html