依赖倒置原则

最新推荐文章于 2024-08-10 16:13:20 发布

weixin_44564365

最新推荐文章于 2024-08-10 16:13:20 发布

阅读量96

点赞数

文章标签： java 依赖倒置设计原则

本文链接：https://blog.csdn.net/weixin_44564365/article/details/87894942

版权

定义：

高层模块不应该依赖低层模块，两者都应该依赖其抽象；
抽象不应该依赖细节；
细节应该依赖抽象。

高层模块和低层模块容易理解，每一个逻辑的实现都是由原子逻辑组成的，不可分割的原子逻辑就是低层模块，原子逻辑的再组装就是高层模块。

那什么是抽象，什么又是细节呢？在Java语言中，抽象就是指接口或抽象类，两者都是不能直接被实例化的；细节就是实现类，实现接口或继承抽象类而产生的类就是细节，其特点就是可以直接被实例化，也就是可以加上一个关键字new产生一个对象。

依赖倒置原则在Java语言中的表现就是：

模块间的依赖是通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的； -
接口或抽象类不依赖于实现类；
实现类依赖接口或抽象类。

举个例子说明依赖倒置的好处：
比如去商店买宠物猪，下面是类图：
在这里插入图片描述
代码：
粉色猪类

public class PinkPig {
    public void buyPig(){
        System.out.println("买了一只粉猪");
    }
}

买猪的人的类

public class PeopleBuyPig {
    public void buy(PinkPig pinkPig){
        pinkPig.buyPig();
    }
}

场景类

public class PeopleBuyPig {
    public void buy(PinkPig pinkPig){
        pinkPig.buyPig();
    }
}

这个人买完以后觉得挺好，想买个黑猪给粉猪做伴，于是去买一个黑猪：

public class BlackPig {
    public void buyPig(){
        System.out.println("买了一只黑猪");
    }
}

但是黑猪出来了，没办法买，因为和粉猪紧耦合了，怎么办，只能重新设计了：
在这里插入图片描述
首先创建IPigShop接口

public interface IPigShop {
    void buyPig();
}

在定义一个IBuyPig接口

public interface IBuyPig {
    void buy(IPigShop iPigShop);
}

接口只是一个抽象化的概念，是对一类事物的最抽象描述，具体的实现代码由相应的实现类来完成。

再写黑猪和粉猪的实现

public class BlackPig implements IPigShop{
    public void buyPig(){
        System.out.println("买了一只黑猪");
    }
}

public class PinkPig implements IPigShop{
    public void buyPig(){
        System.out.println("买了一只粉猪");
    }
}

再让买猪的人实现买猪接口

public class PeopleBuyPig implements IBuyPig{
    public void buy(IPigShop iPigShop){
        iPigShop.buyPig();
    }
}

在业务场景中，我们贯彻“抽象不应该依赖细节”，也就是我们认为抽象（IPigShop接口）不依赖BlackPig和PinkPig两个实现类（细节），因此我们在高层次的模块中应用都是抽象。

然后让想买猪的人买猪吧！

public class Client {
    public static void main(String[] args) {
        PeopleBuyPig peopleBuyPig = new PeopleBuyPig();
        //买粉猪
        IPigShop pinkPig = new PinkPig();
        peopleBuyPig.buy(pinkPig);
        //买黑猪
        IPigShop blackPig = new BlackPig();
        peopleBuyPig.buy(blackPig);
    }
}

Client属于高层业务逻辑，它对低层模块的依赖都建立在抽象上。在新增加低层模块时，只修改了业务场景类，也就是高层模块，对其他低层模块如Driver类不需要做任何修改，业务就可以运行，把“变更”引起的风险扩散降低到最小。

依赖的三种方法：

构造函数传递依赖对象
在类中通过构造函数声明依赖对象，按照依赖注入的说法，这种方式叫做构造函数注入：

//接口
public interface IBuyPig {
    void buy();
}
//实现
public class PeopleBuyPig implements IBuyPig{

    private IPigShop iPigShop;

    public PeopleBuyPig(IPigShop iPigShop){
        this.iPigShop = iPigShop;
    }

    public void buy(){
        this.iPigShop.buyPig();
    }
}

Client类：

public class Client {
    public static void main(String[] args) {
        //买粉猪
        IPigShop pinkPig = new PinkPig();
        PeopleBuyPig peopleBuyPig = new PeopleBuyPig(pinkPig);
        peopleBuyPig.buy();
     }
}

Setter方法传递依赖对象

在抽象中设置setter方法声明依赖关系，依照依赖注入的说法就是setter依赖注入

public interface IBuyPig {
    void setPigShop(IPigShop pigShop);
    void buy();
}

public class PeopleBuyPig implements IBuyPig{

    private IPigShop pigShop;

    @Override
    public void setPigShop(IPigShop pigShop) {
        this.pigShop = pigShop;
    }
    public void buy(){
        this.pigShop.buyPig();
    }
}

public class Client {
    public static void main(String[] args) {
        //买粉猪
        IBuyPig peopleBuyPig = new PeopleBuyPig();
        IPigShop pinkPig = new PinkPig();
        peopleBuyPig.setPigShop(pinkPig);
        peopleBuyPig.buy();
    }
}