接口隔离原则

• 在介绍接口隔离原则之前我们先看下面举例说明中的第一个例子——反例

一、举例说明

1.反例

（1）类图说明

• 因为类图比较清晰，我们先看类图

• 可以看出， DogPlays.java 和 CatPlays.java 分别实现了接口PetInterface ，DogPlaysUse 和 CatPlaysUse 又分别通过该接口依赖 DogPlays 和 CatPlays ，但是都没有用完实现类里的所有方法，造成资源浪费

（2）代码说明

• 如果类图不是很明白的，直接看代码感受一下！
• 直接上代码：

package com.liu.susu.principle.segregation.example1;

import org.springframework.stereotype.Service;

/**
 * @Description 接口隔离原则——反例
 * @Author susu
 * @date 2022-02-12
 **/
public interface PetInterface {
    void playBall();//玩球
    void climbTree();//爬树
    void catchMouse();//抓老鼠
    void likeToGoOut();//遛狗
}

@Service("dog")
class DogPlays implements PetInterface{
    @Override
    public void playBall() {
        System.out.println("狗狗喜欢玩球……");
    }
    public void climbTree() {
        System.out.println("DogPlays类 实现了 climbTree 方法");
    }
    public void catchMouse() {
        System.out.println("DogPlays类 实现了 catchMouse 方法");
    }
    public void likeToGoOut() {
        System.out.println("狗狗喜欢每天被遛遛……");
    }
}

@Service
class CatPlays implements PetInterface{
    public void playBall() {
        System.out.println("小猫喜欢玩球……");
    }
    public void climbTree() {
        System.out.println("小猫喜欢爬树……");
    }
    public void catchMouse() {
        System.out.println("小猫喜欢抓老鼠……");
    }
    public void likeToGoOut() {
        System.out.println("CatPlays 类 实现了 likeToGoOut 方法");
    }
}

/**
 * DogPlaysUse 类通过接口PetInterface 依赖（使用）DogPlays类，
 * 但是只用到 playBall 和 likeToGoOut 方法
 */
@Service
class DogPlaysUse {
    public void playBall(PetInterface petInterface){
        petInterface.playBall();
    }
    public void likeToGoOut(PetInterface petInterface) {
        petInterface.likeToGoOut();
    }
}
/**
 * CatPlaysUse 类通过接口PetInterface 依赖（使用）DogPlays类，
 * 但是只用到 playBall、climbTree 和 catchMouse 方法
 */
@Service
class CatPlaysUse {
    public void playBall(PetInterface petInterface){
        petInterface.playBall();
    }
    public void climbTree(PetInterface petInterface) {
        petInterface.climbTree();
    }
    public void catchMouse(PetInterface petInterface) {
        petInterface.catchMouse();
    }
}


class Test {
    public static void main(String[] args) {
        //DogPlaysUse 这个类通过接口 依赖 DogPlays 类
        DogPlaysUse dogPlaysUse = new DogPlaysUse();
        dogPlaysUse.playBall(new DogPlays());
        dogPlaysUse.likeToGoOut(new DogPlays());

        System.out.println("\n======小猫开始表演……=====\n" );
        //DogPlaysUse 这个类通过接口 依赖 CatPlays 类
        CatPlaysUse catPlaysUse = new CatPlaysUse();
        catPlaysUse.playBall(new CatPlays());

    }
}

测试类

package com.liu.susu.principle.segregation.example1;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @FileName PetController
 * @Description
 * @Author susu
 * @date 2022-02-12
 **/
@Controller
@RequestMapping("/dog")
public class PetController {

    @Autowired
    @Qualifier("dog")
    private PetInterface petInterface;

    @Autowired
    @Qualifier("catPlays")
    private PetInterface petInterface2;

    @Autowired
    private DogPlaysUse dogPlaysUse;
    @Autowired
    private CatPlaysUse catPlaysUse;

    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        dogPlay();
        catPlay();
        return "hello world!";
    }
    public void dogPlay(){
        dogPlaysUse.playBall(petInterface);
        System.out.println("dogPlaysUse.playBall(petInterface)--->ok");
    }
    public void catPlay(){
        catPlaysUse.playBall(petInterface2);
        System.out.println("catPlaysUse.playBall(petInterface2)--->ok");
    }

}

（4）分析缺点（总结）
可以看出，PetInterface 的实现有两个，分别是 DogPlays.java 和 CatPlays.java
DogPlaysUse 这个类通过接口 PetInterface 依赖 DogPlays 类，但是只用到 playBall 和 likeToGoOut 方法。
而 DogPlays 类实现了 PetInterface 接口的所有方法，所以造成浪费
同样的，CatPlaysUse 这个类通过接口 PetInterface 依赖 CatPlays 类，但是只用到 playBall、climbTree 和 catchMouse 方法，所以也造成浪费
2.正例
那么对于上面的案例怎么来优化呢？
既然一个接口有浪费，那么我们就把它拆解，这其实就是我们的接口隔离原则，请继续……
（1）类图说明

• 如图可见，对于上述案例，如果用接口隔离原则优化的话，我们设计的时候拆成3个接口最为合理

（2）代码说明

package com.liu.susu.principle.segregation.example2;

/**
 * @Description 接口隔离原则——正例
 * @Author susu
 * @date 2022-02-12
 **/
public interface PetInterface {
    void playBall();//玩球
}
interface DogInterface {
    void likeToGoOut();//遛狗
}
interface CatInterface {
    void climbTree();//爬树
    void catchMouse();//抓老鼠
}

class DogPlays implements PetInterface,DogInterface{
    public void playBall() {
        System.out.println("狗狗喜欢玩球……");
    }
    public void likeToGoOut() {
        System.out.println("狗狗喜欢每天被遛遛……");
    }
}

class CatPlays implements PetInterface,CatInterface{
    public void playBall() {
        System.out.println("小猫喜欢玩球……");
    }
    public void climbTree() {
        System.out.println("小猫喜欢爬树……");
    }
    public void catchMouse() {
        System.out.println("小猫喜欢抓老鼠……");
    }
}

class DogPlaysUse {
    public void playBall(PetInterface petInterface){
        petInterface.playBall();
    }
    public void likeToGoOut(DogInterface dogInterface) {
        dogInterface.likeToGoOut();
    }
}

class CatPlaysUse {
    public void playBall(PetInterface petInterface){
        petInterface.playBall();
    }
    public void climbTree(CatInterface catInterface) {
        catInterface.climbTree();
    }
    public void catchMouse(CatInterface catInterface) {
        catInterface.catchMouse();
    }
}

/**
 * 测试类
 */
class Test{
    public static void main(String[] args) {
        DogPlaysUse dogPlaysUse = new DogPlaysUse();
        dogPlaysUse.playBall(new DogPlays());
        dogPlaysUse.likeToGoOut(new DogPlays());

        System.out.println("\n======小猫开始表演……=====\n" );

        CatPlaysUse catPlaysUse = new CatPlaysUse();
        catPlaysUse.playBall(new DogPlays());
        catPlaysUse.climbTree(new CatPlays());
        catPlaysUse.catchMouse(new CatPlays());

    }
}

（4）方案评价
对比第一种写法，使用接口隔离的这种写法明显让旁人看着代码也是很清晰，接口拆开之后各行其职责，代码看着不臃肿，后续功能变更或新增的话维护起来也好维护
三、总结
客户端不应该依赖它不需要的接口
一个类对另外一个类的依赖，应建立在最小的接口上，其实就是一个接口里不要放一个功能模块外的其他方法，理解起来跟单一职责原则有点像，自己体会体会吧