精华内容
下载资源
问答
  • 依赖倒置原则

    2019-02-24 16:55:11
    依赖倒置原则

    定义:

    • 高层模块不应该依赖低层模块,两者都应该依赖其抽象;
    • 抽象不应该依赖细节;
    • 细节应该依赖抽象。

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

    那什么是抽象,什么又是细节呢?在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();
        }
    }
    

    接口声明依赖对象

    在接口的方法中声明依赖对象,开始写的例子就是采用了接口声明依赖的方式,,该方法也叫做接口注入。

    总结:

    依赖倒转原则的本质就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立,不互相影响,实现模块间的松耦合,我们怎么在项目中使用这个规则呢?只要遵循以下的几个规则就可以:

    1. 每个类尽量都有接口或抽象类,或者抽象类和接口两者都具备。
    2. 变量的显示类型尽量是接口或者是抽象类。
    3. 任何类都不应该从具体类派生。
    4. 尽量不要覆写基类的方法。
    5. 结合里氏替换原则使用

    参考:https://www.cnblogs.com/yulang314/p/3551586.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,170
精华内容 2,468
关键字:

依赖倒置原则