java设计模式——依赖倒置原则

一、概念

1、定义：

• 高层模块(即controller层)不应该依赖低层模块(即service层或者dao层)，二者都应该依赖其抽象。
• 抽象不应该依赖细节，细节应该依赖抽象。
• 针对接口编程，不要针对实现编程。

2、优点：

• 可以减少类间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。

二、依赖倒置原则简单示例

1、示例1：

• 不使用依赖倒置原则，输出张三所有的所有课程

（1）、定义一个人员为张三学习课程的类

package com.rf.rules.dependenceinversion;

/**
 * @description: 张三人员类
 * @author: xiaozhi
 * @create: 2020-05-02 21:13
 */
public class Zhangsan {

    public void studyJavaCourse(){
        System.out.println("张三学习java课程");
    }
    public void studyPythonCourse(){
        System.out.println("张三学习python课程");
    }
    public void studyVueCourse(){
        System.out.println("张三学习vue课程");
    }


}

（2）、定义一个测试类

package com.rf.rules.dependenceinversion;

/**
 * @description: 测试类
 * @author: xiaozhi
 * @create: 2020-05-02 21:14
 */
public class Test {
    public static void main(String[] args) {
        Zhangsan zs=new Zhangsan();
        zs.studyJavaCourse();
        zs.studyPythonCourse();
        zs.studyVueCourse();
    }
}

（3）输出结果如下： 2、示例2

• 使用依赖倒置原则，根据接口方法的方式，输出张三所有的所有课程

（1）、定义一个学习课程的接口类

package com.rf.rules.dependenceinversion;
/** 
* @Description: 学习课程的接口类
* @Param:  
* @Author: xz  
* @return: 
* @Date: 2020/5/2 21:30  
*/ 
public interface ICourse {
    //学习课程方法
    void studyCourse();
}

（2）、定义一个学习java课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习java课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:31
 */
public class JavaCourse implements ICourse{

    @Override
    public void studyCourse() {
        System.out.println("张三学习java课程");
    }
}

（3）、定义一个学习python课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习python课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:32
 */
public class PythonCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("张三学习python课程");
    }
}

（4）、定义一个学习vue课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习vue课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:32
 */
public class VueCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("张三学习vue课程");
    }
}

（5）、定义一个人员为张三学习课程的类

package com.rf.rules.dependenceinversion;

/**
 * @description: 张三人员类
 * @author: xiaozhi
 * @create: 2020-05-02 21:13
 */
public class Zhangsan {

    public void StudyBaiduCourse(ICourse iCourse){
        iCourse.studyCourse();
    }
}

（6）、定义一个测试类

package com.rf.rules.dependenceinversion;

/**
 * @description: 测试类
 * @author: xiaozhi
 * @create: 2020-05-02 21:14
 */
public class Test {
    public static void main(String[] args) {
        Zhangsan zs=new Zhangsan();
        zs.StudyBaiduCourse(new JavaCourse());
        zs.StudyBaiduCourse(new PythonCourse());
        zs.StudyBaiduCourse(new VueCourse());
    }
}

（7）、输出结果如下： （8）、类关系图如下： 3、示例3

• 使用依赖倒置原则，根据构造器的方式，输出张三所有的所有课程

（1）、定义一个学习课程的接口类

package com.rf.rules.dependenceinversion;
/** 
* @Description: 学习课程的接口类
* @Param:  
* @Author: xz  
* @return: 
* @Date: 2020/5/2 21:30  
*/ 
public interface ICourse {
    //学习课程方法
    void studyCourse();
}

（2）、定义一个学习java课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习java课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:31
 */
public class JavaCourse implements ICourse{

    @Override
    public void studyCourse() {
        System.out.println("张三学习java课程");
    }
}

（3）、定义一个学习python课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习python课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:32
 */
public class PythonCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("张三学习python课程");
    }
}

（4）、定义一个学习vue课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习vue课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:32
 */
public class VueCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("张三学习vue课程");
    }
}

（5）、定义一个人员为张三学习课程的类

package com.rf.rules.dependenceinversion;

/**
 * @description: 张三人员类
 * @author: xiaozhi
 * @create: 2020-05-02 21:13
 */
public class Zhangsan {
    private ICourse iCourse;
	//通过构造器的方式
    public Zhangsan(ICourse iCourse){
        this.iCourse=iCourse;
    }
    //方法不需要指定参数
    public void StudyBaiduCourse(){
        iCourse.studyCourse();
    }

}

（6）、定义一个测试类

package com.rf.rules.dependenceinversion;

/**
 * @description: 测试类
 * @author: xiaozhi
 * @create: 2020-05-02 21:14
 */
public class Test {
     public static void main(String[] args) {
        Zhangsan zs=new Zhangsan(new JavaCourse());
        Zhangsan zs1=new Zhangsan(new PythonCourse());
        Zhangsan zs2=new Zhangsan(new VueCourse());
        zs.StudyBaiduCourse();
        zs1.StudyBaiduCourse();
        zs2.StudyBaiduCourse();
    }
}

（7）、输出结果如下： 4、示例4

• 使用依赖倒置原则，根据构造器的方式，高层模块（即controller层）不需要new更多实例，输出张三所有的所有课程

（1）、定义一个学习课程的接口类

package com.rf.rules.dependenceinversion;
/** 
* @Description: 学习课程的接口类
* @Param:  
* @Author: xz  
* @return: 
* @Date: 2020/5/2 21:30  
*/ 
public interface ICourse {
    //学习课程方法
    void studyCourse();
}

（2）、定义一个学习java课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习java课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:31
 */
public class JavaCourse implements ICourse{

    @Override
    public void studyCourse() {
        System.out.println("张三学习java课程");
    }
}

（3）、定义一个学习python课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习python课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:32
 */
public class PythonCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("张三学习python课程");
    }
}

（4）、定义一个学习vue课程类，实现学习课程的接口类

package com.rf.rules.dependenceinversion;

/**
 * @description: 学习vue课程类
 * @author: xiaozhi
 * @create: 2020-05-02 21:32
 */
public class VueCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("张三学习vue课程");
    }
}

（5）、定义一个人员为张三学习课程的类

package com.rf.rules.dependenceinversion;

/**
 * @description: 张三人员类
 * @author: xiaozhi
 * @create: 2020-05-02 21:13
 */
public class Zhangsan {
    private ICourse iCourse;
    //set构造器
	public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }
    
    //方法不需要指定参数
    public void StudyBaiduCourse(){
        iCourse.studyCourse();
    }

}

（6）、定义一个测试类

package com.rf.rules.dependenceinversion;

/**
 * @description: 测试类
 * @author: xiaozhi
 * @create: 2020-05-02 21:14
 */
public class Test {
     public static void main(String[] args) {
        Zhangsan zs=new Zhangsan();
        zs.setiCourse(new JavaCourse());
        zs.StudyBaiduCourse();

        zs.setiCourse(new PythonCourse());
        zs.StudyBaiduCourse();

        zs.setiCourse(new VueCourse());
        zs.StudyBaiduCourse();
    }
}

（7）、输出结果如下：

三、理解依赖倒置原则义

当我们的人员张三类(Zhangsan)增加折学习课程功能的时候，在不改变人员张三类(Zhangsan)类的情况下，通过创建一个课程接口（ICourse）和课程接口的具体实现类(JavaCourse、PythonCourse等)，完成人员学习课程的需求扩展。