设计原则之依赖倒置

设计原则之依赖倒置

一、依赖倒置是什么？

简单的说，依赖倒置就是把自己操作对象的权利交出去，这也是IOC/DI的原型，废话不多说，在一些时候自己操作对象并不是一个明智的觉得，天知道对象会被我们自己管理成什么样，废话不多说，直接看代码

1.版本一

代码如下（示例）：

public class Tom {
    public void studyJavaCourse(){
        System.out.println("Tom正在学习Java课程");
    }

    public void studyPythonCourse(){
        System.out.println("Tom正在学习Python课程");
    }

    public void studyAICourse(){
        System.out.println("Tom正在学习AI课程");
    }
    public static void main(String[] args) {
	   Tom tom = new Tom();
	   tom.studyJavaCourse();
	   tom.studyPythonCourse();
	   tom.studyAICourse();
    }
}

这是经常会用到的一种方法调用方式，但是这种方式也有很多缺陷，比如代码量会很多，很臃肿。其次调用次数导致代码复杂度变高，如果后期要新加功能或者优化原有的功能，可能会触及到很多改动，所以我们优化版本二

2.版本二

代码如下（示例）：

public interface ICourse {
    void study();
}

public class JavaCourse implements ICourse {
    public void study() {
        System.out.println("Tom正在学习Java课程");
    }
}

public class PythonCourse implements ICourse {
    public void study() {
        System.out.println("Tom正在学习Python课程");
    }
}

public class Tom {
    public void study(ICourse course){
        course.study();
    }
    
    public static void main(String[] args) {
        Tom tom = new Tom();
        tom.study(new JavaCourse());
        tom.study(new PythonCourse());
	}
}

版本二明显要比版本一的结构更加合理，通过接口抽象，将功能方法独立于对象本身，将调用方当作参数传递出去，就能实现我们解耦的目的，也方便了后期代码更新迭代，减小整体系统的影响，但是也是有一定的问题，每次调用都需要去创建一个子类的实例出来，这样接增大了内存的开销，所以我们继续优化

3.版本三

代码如下（示例）：

public interface ICourse {
    void study();
}

public class JavaCourse implements ICourse {
    public void study() {
        System.out.println("Tom正在学习Java课程");
    }
}

public class PythonCourse implements ICourse {
    public void study() {
        System.out.println("Tom正在学习Python课程");
    }
}

public class Tom {
    private ICourse iCourse;

    public Tom(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void study(){
        iCourse.study();
    }
    public static void main(String[] args) {
        Tom tom = new Tom(new JavaCourse());
        tom.study();
	}
}

现在版本三可以支持多次调用了，不用去创建那么多对象，只需要初始化一次，后续的调用就可以一直用啦，但是此处就又衍生出一个问题，如果我们使用完Java课程以后又想使用Python课程怎么办，又得去新建一个Tom对象，所以对于Tom来说他是重复的，我们并没有用到那么对，只需要一个就够了，所以接下来我们继续优化一个版本

4.版本四

代码如下（示例）：

public interface ICourse {
    void study();
}

public class JavaCourse implements ICourse {
    public void study() {
        System.out.println("Tom正在学习Java课程");
    }
}

public class PythonCourse implements ICourse {
    public void study() {
        System.out.println("Tom正在学习Python课程");
    }
}

public class Tom {
    private ICourse iCourse;

    public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void study(){
        iCourse.study();
    }
    public static void main(String[] args) {
        Tom tom = new Tom();
        JavaCourse javaCourse = new JavaCourse();
        tom.setiCourse(javaCourse);
        tom.study();
	}
}

至此，我们的优化也就完成了，相信最终整个优化的流程也能为大家解释什么是依赖倒置了，总之一句话，依赖倒置就是把原先我们要去调用的操作交出去，不要自己去用，这样能大大的提高代码的复用程度

总结

以上就是今天要讲的内容，原创不易，感谢支持。