亲宝软件园·资讯

展开

Java接口隔离原则

温故知新之java 人气:0

定义

接口隔离原则(Interface Segregation Principle),又称为ISP原则,官方定义为

1.客户端不应该依赖它不需要的接口

2.类间的依赖关系应该建立在最小的接口上

简单点来讲就是在一个类中不要定义过多的方法,接口应该尽量简单细化

案例

需求

假设有这样一个案例场景,现在有一个接口Repair,给定他有三个能力,可以修汽车,修火车,修飞机, 两个实现类张师傅,李师傅分别具有这些能力,有一个4S店类,假设是需要张师傅来修汽车和修飞机,而另一个4s店类需要李师傅来修汽车和修火车

方案一

定义维修接口类Repair.java

/**
 * 维修类
 * @author:liyajie
 * @createTime:2022/1/29 17:00
 * @version:1.0
 */
public interface Repair {

    /**
     * 维修汽车
     * @author: liyajie
     * @date: 2022/1/29 17:03
     * @param
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    void car();

    /**
     * 维修火车
     * @author: liyajie
     * @date: 2022/1/29 17:03
     * @param
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    void train();

    /**
     * 维修飞机
     * @author: liyajie
     * @date: 2022/1/29 17:03
     * @param
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    void air();
}

维修李师傅类RepairLi.java

/**
 * 维修类
 * @author:liyajie
 * @createTime:2022/1/29 17:00
 * @version:1.0
 */
public class RepairLi implements Repair{


    @Override
    public void car() {
        System.out.println("李师傅修汽车");
    }

    @Override
    public void train() {
        System.out.println("李师傅修火车");
    }

    @Override
    public void air() {
        System.out.println("李师傅修飞机");
    }
}

维修王师傅类RepairWang.java

/**
 * 维修类
 * @author:liyajie
 * @createTime:2022/1/29 17:00
 * @version:1.0
 */
public class RepairWang implements Repair{

    @Override
    public void car() {
        System.out.println("王师傅修汽车");
    }

    @Override
    public void train() {
        System.out.println("王师傅修火车");
    }

    @Override
    public void air() {
        System.out.println("王师傅修飞机");
    }
}

4s店1

/**
 * 4s店1
 * @author:liyajie
 * @createTime:2022/1/29 17:07
 * @version:1.0
 */
public class S1Shop {

    /**
     * 修汽车
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repair
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void car(Repair repair){
        repair.car();
    }

    /**
     * 修火车
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repair
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void train(Repair repair){
        repair.train();
    }
}

4s店2

/**
 * 4s店2
 * @author:liyajie
 * @createTime:2022/1/29 17:07
 * @version:1.0
 */
public class S2Shop {
    /**
     * 修汽车
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repair
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void car(Repair repair){
        repair.car();
    }

    /**
     * 修飞机
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repair
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void air(Repair repair){
        repair.air();
    }
}

测试类1

/**
 * 测试类1
 * @author:liyajie
 * @createTime:2022/1/29 16:46
 * @version:1.0
 */
public class Test1 {
    public static void main(String[] args) {
        // 4s店1
        new S1Shop().car(new RepairLi());
        new S1Shop().train(new RepairLi());

        // 4s店2
        new S2Shop().car(new RepairWang());
        new S2Shop().air(new RepairWang());
    }
}

方案二

定义维修汽车接口

/**
 * 维修类
 * @author:liyajie
 * @createTime:2022/1/29 17:00
 * @version:1.0
 */
public interface RepairCar {

    /**
     * 维修汽车
     * @author: liyajie
     * @date: 2022/1/29 17:03
     * @param
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    void car();
}

定义维修火车类

/**
 * 维修类
 * @author:liyajie
 * @createTime:2022/1/29 17:00
 * @version:1.0
 */
public interface RepairTrain {

    /**
     * 维修火车
     * @author: liyajie
     * @date: 2022/1/29 17:03
     * @param
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    void train();
}

定义维修飞机类

/**
 * 维修类
 * @author:liyajie
 * @createTime:2022/1/29 17:00
 * @version:1.0
 */
public interface RepairAir {

    /**
     * 维修飞机
     * @author: liyajie
     * @date: 2022/1/29 17:03
     * @param
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    void air();
}

4s店1

/**
 * 4s店1
 * @author:liyajie
 * @createTime:2022/1/29 17:07
 * @version:1.0
 */
public class S1ShopNew {

    /**
     * 修汽车
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repairCar
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void car(RepairCar repairCar){
        repairCar.car();
    }

    /**
     * 修火车
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repairTrain
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void train(RepairTrain repairTrain){
        repairTrain.train();
    }
}

4s店2

/**
 * 4s店2
 * @author:liyajie
 * @createTime:2022/1/29 17:07
 * @version:1.0
 */
public class S2ShopNew {
    /**
     * 修汽车
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repairCar
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void car(RepairCar repairCar){
        repairCar.car();
    }

    /**
     * 修飞机
     * @author: liyajie
     * @date: 2022/1/29 17:10
     * @param repairAir
     * @return void
     * @exception:
     * @update:
     * @updatePerson:
     **/
    public void air(RepairAir repairAir){
        repairAir.air();
    }
}

测试类

/**
 * 测试类1
 * @author:liyajie
 * @createTime:2022/1/29 16:46
 * @version:1.0
 */
public class Test2 {
    public static void main(String[] args) {
        // 4s店1
        new S1ShopNew().car(new RepairLiNew());
        new S1ShopNew().train(new RepairLiNew());

        // 4s店2
        new S2ShopNew().car(new RepairWangNew());
        new S2ShopNew().air(new RepairWangNew());
    }
}

对比分析

方案一,违反了接口隔离原则,因为李师傅和王师傅都实现了维修接口的三个方法:修汽车,修火车,修飞机。但需求中并不需要这么多,只需要李师傅修汽车和火车,王师傅修汽车和飞机,依赖关系不是建立在最小接口上

方案二,遵守了接口隔离原则,对李师傅和王师傅类都进行了接口隔离,实现了各自的两个方法,避免了耦合

总结

通过上面两个案例,我们可以得到以下结论: 接口隔离原则就是当我一个类通过接口依赖(使用)另一个类的时候,要保证依赖的该接口是最小的,接口里面有方法用不到的,就进行隔离,而隔离的做法就是,就对原来接口进行拆分,拆分为最小粒度,来避免耦合。

小知识点

有没有发现接口隔离原则与我们上一篇的单一职责原则有点相似,来看下他们的相同点和不同点吧

相同点

都要求对结构进行拆分,都要求更小的粒度,都希望减少耦合

不同点

1.单一职责原则:类与接口职责单一,注重的是职责

2.接口隔离原则:要求我们尽量使用多个专门的接口,注重的是接口的设计

加载全部内容

相关教程
猜你喜欢
用户评论