设计原则之依赖倒置原则

简介: 设计原则之依赖倒置原则

博主介绍: ✌博主从事应用安全和大数据领域,有8年研发经验,5年面试官经验,Java技术专家✌

Java知识图谱点击链接:体系化学习Java(Java面试专题)

💕💕 感兴趣的同学可以收藏关注下不然下次找不到哟💕💕

依赖倒置原则

依赖倒置原则 Dependence Inversion Principle, DIP。
《设计模式之禅》第三章介绍到:
High level modules should not depend upon low level modules. Both should depend uporabstractions. Abstractions should not depend upon details, Details should depend uponabstractions.

这上面主要讲三个含义,这个是可以在面试中陈述的,说明依赖倒置原则的特点:
1、高层模块不应该依赖低层模块,两者都应该依赖其抽象
2、抽象不能依赖细节
3、细节应该依赖抽象

我们接下来介绍依赖倒置的三种写法

依赖倒置的三种写法

1、接口传递

package com.pany.camp.design.principle.lsp;

/**
 *
 * @description:  车子的抽象类
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: panyong 
 * @version: 1.0.0 
 * @createTime: 2023-05-31 13:26
 */
public abstract class Car {
   
   

    /**
     * 启动
     *
     * @since 1.0.0
     * @param
     * @return: void
     * @author: panyong
     * @version: 1.0.0
     * @createTime: 2023-05-31 13:28
     */
    abstract void firing();

    /**
     * 车子的牌子
     *
     * @since 1.0.0
     * @param
     * @return: String
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-05-31 13:36
     */
    abstract String getName();
}
AI 代码解读
package com.pany.camp.design.principle.lsp;

/**
 *
 * @description: 法拉利
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-05-31 13:40
 */
public class Ferrari extends Car {
   
   
    @Override
    void firing() {
   
   
        System.out.println("drive ferrari");
    }

    @Override
    String getName() {
   
   
        return "ferrari";
    }
}
AI 代码解读
package com.pany.camp.design.principle.lsp;
/**
 *
 * @description:  保时捷
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-05-31 13:30
 */
public class Porsche extends Car {
   
   

    @Override
    void firing() {
   
   
        System.out.println("drive porsche");
    }

    @Override
    String getName() {
   
   
        return "porsche";
    }
}
AI 代码解读
package com.pany.camp.design.principle.lsp;

public class User {
   
   

    public void drive(Car car) {
   
   
        car.firing();
        System.out.println("drive " + car.getName());
    }

    public static void main(String[] args) {
   
   
        User user = new User();

        // 我可以换成其他的方式,并没有改变代码的逻辑
        user.drive(new Porsche());
        user.drive(new Ferrari());
    }
}
AI 代码解读

2、构造器传递

package com.pany.camp.design.principle.dip;

/**
 *
 * @description: 电脑
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-05-31 21:13
 */
public interface Computer {
   
   

    /**
     * 打游戏
     *
     * @since 1.0.0
     * @param
     * @return: void
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-05-31 21:14
     */
    void playGame();
}
AI 代码解读
package com.pany.camp.design.principle.dip;

/**
 *
 * @description: 惠普
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-05-31 21:15
 */
public class Hp implements Computer {
   
   

    @Override
    public void playGame() {
   
   
        System.out.println("I use Hp computer, start play game");
    }
}
AI 代码解读
package com.pany.camp.design.principle.dip;

/**
 *
 * @description:  学生
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-05-31 21:15
 */
public class Student {
   
   

    private Computer computer;

    public Student(Computer computer) {
   
   
        this.computer = computer;
    }

    /**
     * 开始打游戏
     *
     * @since 1.0.0
     * @param
     * @return: void
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-05-31 21:17
     */
    public void startPlayGame() {
   
   
        this.computer.playGame();
    }

    /**
     * 测试方法
     *
     * @since 1.0.0
     * @param
     * @param args
     * @return: void
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-05-31 21:17
     */
    public static void main(String[] args) {
   
   
        Student student = new Student(new Hp());
        student.startPlayGame();
    }
}
AI 代码解读

3、set 方法传递在这里插入代码片

在构造器例子的基础上,新写一个 User,通过 set 方法传递。

package com.pany.camp.design.principle.dip;

/**
 *
 * @description:  学生
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-05-31 21:15
 */
public class User {
   
   

    private Computer computer;

    public void setComputer(Computer computer) {
   
   
        this.computer = computer;
    }

    /**
     * 开始打游戏
     *
     * @since 1.0.0
     * @param
     * @return: void
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-05-31 21:17
     */
    public void startPlayGame() {
   
   
        this.computer.playGame();
    }

    /**
     * 测试方法
     *
     * @since 1.0.0
     * @param
     * @param args
     * @return: void
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-05-31 21:17
     */
    public static void main(String[] args) {
   
   
        User user = new User();
        user.setComputer(new Hp());
        user.startPlayGame();
    }
}
AI 代码解读

1686494501743.jpg

💕💕 本文由激流丶创作,原创不易,感谢支持!
💕💕喜欢的话记得点赞收藏啊!

目录
打赏
0
0
0
0
52
分享
相关文章
软件架构设计原则之依赖倒置原则
依赖倒置原则(Dependence Inversion Principle,DIP)是指设计代码结构时,高层模块不应该依赖低层模块,二者都应该依赖其抽象。抽象不应该依赖细节,细节应该依赖抽象。通过依赖倒置,可以减少类与类之间的耦合性,提高系统的稳定性,提高代码的可读性和可维护性,并且能够降低修改程序所造成的风险。接下来看一个案例,还是以Course(课程)为例,先来创建一个类Tom:
106 0
接口隔离原则|设计原则
今天为大家带来的依旧是 设计原则 的知识: 接口隔离原则
单一职责原则|设计原则
本文带大家学习和了解第一种设计原则,单一职责原则
开闭原则|设计原则(二)
由于在软件体系中,唯一不变的,就是软件一直在变。
开闭原则|设计原则(一)
由于在软件体系中,唯一不变的,就是软件一直在变。
软件架构设计原则--依赖倒置原则
本专栏内容参考自:咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》,仅作个人学习记录使用,如有侵权,联系速删
软件架构设计原则--依赖倒置原则
软件架构设计原则之接口隔离原则
接口隔离原则符合我们常说的高内聚、低耦合的设计思想,可以使类具有很好的可读性、可扩展性和可维护性。我们在设计接口的时候,要多花时间去思考,要考虑业务模型,包括对以后有可能发生变更的地方还要做一些预判。所以,对于抽象、对于业务模型的理解是非常重要的。下面我们来看一段代码,对一个动物行为进行抽象描述。
110 0
七大设计原则之依赖倒置原则应用
七大设计原则之依赖倒置原则应用
64 0
里氏替换原则|设计原则
里氏替换原则的内容可以描述为: “派生类(子类)对象可以在程序中代替其基类(超类)对象。”

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等