2. 接口隔离原则

一、不遵循改规则

• 一个类对另外一个类的依赖，应该建立在最小接口的原则上；

package com.day.dreamer.seven.segregation;

public class TraditionalActor {
    public static void main(String[] args) {
        SingerStarManger singerStarManger = new SingerStarManger();
        singerStarManger.work(new SingerStar());

        SportStarManger sportStarManger = new SportStarManger();
        sportStarManger.work(new SportStar());
    }
}

/**
 * 功能混在一起的类
 */
interface Star{
    void eat();
    void sleep();
    void sing();
    void dance();
    void playBasketBall();
}

/**
 * SportStarManger类 通过接口依赖 SportStar类
 * 如果不遵循接口隔离原则，work方法中，就会出现很多不适用于 Sportstar的方法提示
 */
class SingerStarManger{
    public void work(Star star){
        System.out.println("歌手导师入场");
        star.eat();
        star.sleep();
        star.sing();
        star.dance();
    }
}

/**
 * SportStarManger类 通过接口依赖 SportStar类
 * 如果不遵循接口隔离原则，work方法中，就会出现很多不适用于 Singstar的方法提示
 */
class SportStarManger{
    public void work(Star star){
        System.out.println("运动教练入场");
        star.eat();
        star.sleep();
        star.playBasketBall();
    }
}

/**
 * 运动员类实现了接口的所有方法，但运动员不会打篮球
 */
class SportStar implements Star{

    @Override
    public void eat() {
        System.out.println("运动员吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("运动员睡觉");
    }

    @Override
    public void sing() {
        System.out.println("");
    }

    @Override
    public void dance() {
        System.out.println("");
    }

    @Override
    public void playBasketBall() {
        System.out.println("运动员打篮球");
    }
}

/**
 * 歌手类实现了接口的所有方法，但歌手不会打篮球
 */
class SingerStar implements Star{

    @Override
    public void eat() {
        System.out.println("歌手吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("歌手睡觉");
    }

    @Override
    public void sing() {
        System.out.println("歌手唱歌");
    }

    @Override
    public void dance() {
        System.out.println("歌手跳舞");
    }

    @Override
    public void playBasketBall() {
        System.out.println("");
    }
}

二、遵循接口隔离

package com.day.dreamer.seven.segregation;


public class SegregationMan {
    public static void main(String[] args) {
        SingerManManager singerManManager = new SingerManManager();
        singerManManager.operationFirst(new LDHMan());
        singerManManager.operationSecond(new LDHMan());

        SportManManager sportManManager = new SportManManager();
        sportManManager.operationFirst(new SYMan());
        sportManManager.operationSecond(new SYMan());
    }
}

interface SingerMan{
    void sing();
    void dance();
}

interface SportMan{
    void playBasketBall();
}

interface CommonMan{
    void eat();
    void sleep();
}

// 歌星实现类: 刘德华
class LDHMan implements CommonMan,SingerMan{

    @Override
    public void sing() {
        System.out.println("歌星唱歌");
    }

    @Override
    public void dance() {
        System.out.println("歌星跳舞");
    }

    @Override
    public void eat() {
        System.out.println("歌星吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("歌星睡觉");
    }
}

// 运动员星明实现类： 孙杨
class SYMan implements CommonMan,SportMan{

    @Override
    public void playBasketBall() {
        System.out.println("运动员打球");
    }

    @Override
    public void eat() {
        System.out.println("运动员吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("运动员睡觉");
    }
}

// 歌手管理者： 通过接口依赖某个类
class SingerManManager{
    public void operationFirst(CommonMan commonMan){
        commonMan.eat();
        commonMan.sleep();
    }

    public void operationSecond(SingerMan singerMan){
        singerMan.dance();
        singerMan.sing();
    }
}

// 运动员管理者：通过接口依赖某个类
class SportManManager{
    public void operationFirst(CommonMan commonMan){
        commonMan.sleep();
        commonMan.eat();
    }
    public void operationSecond(SportMan sportMan){
        sportMan.playBasketBall();
    }
}