设计原则之依赖倒置原则

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

博主介绍: ✌博主从事应用安全和大数据领域,有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();
}
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";
    }
}
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";
    }
}
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());
    }
}

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();
}
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");
    }
}
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();
    }
}

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();
    }
}

1686494501743.jpg

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

目录
相关文章
|
人工智能 Java Python
七大设计原则之依赖倒置原则应用
七大设计原则之依赖倒置原则应用
57 0
|
设计模式 关系型数据库 数据安全/隐私保护
软件架构设计原则之单一职责原则
单一职责(Simple Responsibility Pinciple,SRP)是指不要存在多于一个导致类变更的原因。假设我们有一个类负责两个职责,一旦发生需求变更,修改其中一个职责的逻辑代码,有可能导致另一个职责的功能发生故障。这样一来,这个类就存在两个导致类变更的原因。如何解决这个问题呢?将两个职责用两个类来实现,进行解耦。后期需求变更维护互不影响。这样的设计,可以降低类的复杂度,提高类的可读性,提高系统的可维护性,降低变更引起的风险。总体来说,就是一个类、接口或方法只负责一项职责。
111 0
软件架构设计原则之单一职责原则
|
设计模式 人工智能 Java
软件架构设计原则之依赖倒置原则
依赖倒置原则(Dependence Inversion Principle,DIP)是指设计代码结构时,高层模块不应该依赖低层模块,二者都应该依赖其抽象。抽象不应该依赖细节,细节应该依赖抽象。通过依赖倒置,可以减少类与类之间的耦合性,提高系统的稳定性,提高代码的可读性和可维护性,并且能够降低修改程序所造成的风险。接下来看一个案例,还是以Course(课程)为例,先来创建一个类Tom:
89 0
|
设计模式 关系型数据库
软件架构设计原则之迪米特法则
迪米特原则(Law of Demeter LoD)是指一个对象应该对其他对象保持最少的了解,又叫最少知道原则(Least Knowledge Principle,LKP),尽量降低类与类之间的耦合度。迪米特原则主要强调:只和朋友交流,不和陌生人说话。出现在成员变量、方法的输入、输出参数中的类都可以称为成员朋友类,而出现在方法体内部的类不属于朋友类。
102 1
|
设计模式 关系型数据库
软件架构设计原则之接口隔离原则
接口隔离原则符合我们常说的高内聚、低耦合的设计思想,可以使类具有很好的可读性、可扩展性和可维护性。我们在设计接口的时候,要多花时间去思考,要考虑业务模型,包括对以后有可能发生变更的地方还要做一些预判。所以,对于抽象、对于业务模型的理解是非常重要的。下面我们来看一段代码,对一个动物行为进行抽象描述。
94 0
|
设计模式 关系型数据库
软件架构设计原则之里氏替换原则
里氏替换原则(Liskov Substitution Principle,LSP)是指如果对每一个类型为T1的对象o1,都有类型为T2的对象O2,使得以T1定义的所有程序P在所有的对象O1都替换成O2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。
75 0
|
设计模式 安全 Java
设计原则之接口隔离原则
设计原则之接口隔离原则
68 0
设计原则之接口隔离原则
|
设计模式 程序员 测试技术
设计模式 - 六大设计原则之SRP(单一职责)
单一职责原则(Single Responsibility Principle, SRP)又称单一功能原则,是面向对象的五个基本原则(SOLID)之一。 它规定一个类应该只有一个发生变化的原因。
256 0
设计模式 - 六大设计原则之SRP(单一职责)
软件架构设计原则--依赖倒置原则
本专栏内容参考自:咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》,仅作个人学习记录使用,如有侵权,联系速删
软件架构设计原则--依赖倒置原则
软件架构设计原则--里氏替换原则
本专栏内容参考自:咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》,仅作个人学习记录使用,如有侵权,联系速删
软件架构设计原则--里氏替换原则