zoukankan      html  css  js  c++  java
  • 依赖倒置原则

    个人博客原文:
    依赖倒置原则

    雪

    设计模式六大原则之三:依赖倒置原则。

    简介

    姓名 :依赖倒置原则

    英文名 :Dependence Inversion Principle

    价值观 :大男子主义的典型代表,什么都得通过老大或者老爸同意

    伴侣 :一定是个温柔体贴的女子

    个人介绍

    1. High level modules should not depend upon low level modules.Both should depend upon abstractions. 高层模块不应该依赖低层模块,两者都应该依赖其抽象(模块间的依赖通过抽象发生,实现类之间不发生直接的依赖关系,其依赖关系是通过接口或抽象类产生的)
    2. Abstractions should not depend upon details. 抽象不应该依赖细节(接口或抽象类不依赖于实现类)
    3. Details should depend upon abstractions. 细节应该依赖抽象(实现类依赖接口或抽象类)

    给大家讲个故事,我胡乱想的,如有雷同,肯定是英雄所见略同。那必须交个朋友。

    一个小村里,有两家饭馆,虽然挂着不同的牌子,挨在一起,但是老板确是表兄弟。这两兄弟抠得很,为了节省成本,密谋了一个想法:在两家饭馆谁家忙的时候,可以让不忙的那家的员工过去支援一下。这样子,本来每家饭馆都需要 2 个洗碗工,总共需要 4 个,他们就只招了 3 个,省了 1 个洗碗工的成本,当然不止洗碗工,还有服务员等等。两兄弟约定了规则:

    1. A 饭馆需要支援的时候,B 饭馆老板,让 B 饭馆老板选哪个员工去支援,不能直接让 A 饭馆的员工直接找 B 饭馆的员工去帮忙,但可以让 A 饭馆员工找 B饭馆老板告知需要支援。
    2. 虽然老板权利大,但是也不能说 A 饭馆老板直接叫 B 饭馆的员工去帮忙。
    3. 员工没有真实的老板,今天为 A 饭馆工作就是 A 饭馆的员工,没有跟定哪个老板。

    大概通过这个小故事,描述了依赖倒置原则的基本内容。

    代码复原

    下面通过代码来模拟这个故事。

    错误的示范

    这个错误的示范将就看哈,可能有些问题没描述清楚。

    老板和员工抽象

    abstract class Boss {
    
        abstract void support();
    
        abstract void askHelp(Boss boss);
    }
    
    abstract class Staff {
    
        private String name;
    
        abstract void service();
    
        abstract void askHelp(Boss boss);
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    老板具体类

    class BossA extends Boss {
    
        private StaffA staffA;
    
        public BossA(StaffA staffA) {
            this.staffA = staffA;
        }
    
        @Override
        void support() {
            staffA.service();
        }
    
        @Override
        void askHelp(Boss boss) {
            boss.support();
        }
    
    }
    
    class BossB extends Boss {
    
        private StaffB staffB;
    
        public BossB(StaffB staffB) {
            this.staffB = staffB;
        }
    
        @Override
        void support() {
            staffB.service();
        }
    
        @Override
        void askHelp(Boss boss) {
            boss.support();
        }
    }
    

    员工具体类

    class StaffA extends Staff {
    
        public StaffA(String name) {
            this.setName(name);
        }
    
        @Override
        void service() {
            System.out.println(this.getName() + "提供服务");
        }
    
        @Override
        void askHelp(Boss boss) {
            boss.support();
        }
    }
    
    class StaffB extends Staff {
    
        public StaffB(String name) {
            this.setName(name);
        }
    
        @Override
        void service() {
            System.out.println(this.getName() + "提供服务");
        }
    
        @Override
        void askHelp(Boss boss) {
            boss.support();
        }
    }
    

    测试代码

    /** 初始化老板和员工 */
    StaffA staffA = new StaffA("A 员工");
    StaffB staffB = new StaffB(" B 员工");
    Boss bossA = new BossA(staffA);
    Boss bossB = new BossB(staffB);
    
    /** A 老板向 B 老板求支援 */
    bossA.askHelp(bossB); // 打印出:B 员工提供服务
    
    /** B 员工向 A 老板求支援 */
    staffB.askHelp(bossA); // 打印出:A 员工提供服务
    

    好像看起来实现了要求了,但是其实这段代码没有按照上面的 3 点规则编写,破坏了第 3 点规则,老板们的员工没有用员工的抽象类,破坏了细节依赖抽象这一点。设想一下,假如现在 A 老板把 A 员工辞退了,重新招了个 C 员工,那么怎么实现呢?是不是需要再新增一个 StaffC 类,然后再修改 BossA 类代码,把 StaffA 换成 StaffC。这样超级麻烦,在平时写项目中要时刻考虑这一点:在具体实现类使用其他类,是不是可以用其抽象类?

    代码:

    DIPErrorTest.java

    正确的示范

    看了上面那个憋屈的代码,再来看下面简洁的代码,才会发现依赖倒置原则是多么强大。

    老板和员工抽象类

    abstract class Boss2 {
    
        private Staff2 staff;
    
        public Boss2(Staff2 staff) {
            this.staff = staff;
        }
    
        abstract void support();
    
        abstract void askHelp(Boss2 boss);
    
        public void setStaff(Staff2 staff) {
            this.staff = staff;
        }
    
        public Staff2 getStaff() {
            return staff;
        }
    }
    
    abstract class Staff2 {
    
        private String name;
    
        abstract void service();
    
        abstract void askHelp(Boss2 boss);
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }
    

    老板类

    class BossImpl extends Boss2 {
    
        public BossImpl(Staff2 staff) {
            super(staff);
        }
    
        @Override
        void support() {
            this.getStaff().service();
        }
    
        @Override
        void askHelp(Boss2 boss) {
            boss.support();
        }
    }
    

    员工类

    class StaffImpl extends Staff2{
    
        public StaffImpl(String name) {
            this.setName(name);
        }
    
        @Override
        void service() {
            System.out.println(this.getName() + "提供服务");
        }
    
        @Override
        void askHelp(Boss2 boss) {
            boss.support();
        }
    }
    

    测试类

    /** 正确示范 */
    Staff2 staffA2 = new StaffImpl("A 员工");
    Staff2 staffB2 = new StaffImpl("B 员工");
    Boss2 bossA2 = new BossImpl(staffA2);
    Boss2 bossB2 = new BossImpl(staffB2);
    
    /** A 老板向 B 老板求支援 */
    bossA2.askHelp(bossB2); // 打印出:B 员工提供服务
    
    /** B 员工向 A 老板求支援 */
    staffB2.askHelp(bossA2); // 打印出:A 员工提供服务
    
    /** A 老板辞退了 A 员工,换成了 C 员工 */
    Staff2 staffC2 = new StaffImpl("C 员工");
    bossA2.setStaff(staffC2);
    
    /** B 员工向 A 老板求支援 */
    staffB2.askHelp(bossA2); // 打印出:C 员工提供服务
    
    

    这代码相比上面错误的示范,简洁了很多,实现的功能却更灵活,这就是依赖倒置原则强大的地方,它可以将类的耦合性降低,提供灵活的处理。

    代码:

    DIPRightTest.java

    最佳实践

    1. 变量的表面类型尽量是接口或者是抽象类
    2. 任何类都不应该从具体类派生
    3. 尽量不要覆写基类的方法
    4. 结合里氏替换原则使用
      (来自《设计模式之禅》)

    总结

    总的来说,要实现依赖倒置原则,要有『面向接口编程』这个思维,掌握好这个思维后,就可以很好的运用依赖倒置原则。

    参考资料:《大话设计模式》、《Java设计模式》、《设计模式之禅》、《研磨设计模式》、《Head First 设计模式》

    希望文章对您有所帮助,设计模式系列会持续更新,感兴趣的同学可以关注公众号,第一时间获取文章推送阅读,也可以一起交流,交个朋友。

    公众号之设计模式系列文章

    公众号

  • 相关阅读:
    观察者模式(Observer)
    怎样解决Java Web项目更改项目名后报错
    MAVEN最佳实践:模块划分
    java.lang.OutOfMemoryError: PermGen space及其解决方法
    以Windows服务方式启动MySQL,并将其默认编码设置为UTF-8
    ubuntu 12.04和Windows 7双系统的安装方法
    允许ubuntu下mysql远程连接
    Linux 系统目录介绍
    SVN中图标符号的含义
    简单介绍Linux下安装Tomcat的步骤
  • 原文地址:https://www.cnblogs.com/liebrother/p/10205927.html
Copyright © 2011-2022 走看看