面向对象原则之一 依赖倒置原则

原文:面向对象原则之一 依赖倒置原则

前言

面向对象有人分为五大原则,分别为单一职责原则、开放封闭原则、依赖倒置原则、接口隔离原则、里氏替换原则。

也有人分为六大原则,分别为单一职责原则、开放封闭原则、依赖倒置原则、接口隔离原则、里氏替换原则、迪米特法则。

现在我们来介绍依赖倒置原则

依赖倒置原则

1)概念

a.高层模块不应该依赖于底层模块,两者应该依赖于其抽象。

b.抽象不应该依赖具体实现,具体实现应该依赖抽象。

上面2点是依赖倒置原则的概念,也是核心。主要是说模块之间不要依赖具体实现,依赖接口或抽象。

其实依赖倒置原则的核心思想是面向接口编程。

2)例子

依赖倒置原则其实也没什么可以说的,下面我们来举个例子吧。

比如,学生看语文书。我们就实现这两个类,一个是学生,一个是语文书。学生依赖于语文书,所以语文书是学生的一个属性。

UML图如下:

类如下。

首先是学生Student类:

public class Student
    {

        public void DoSomething(YuWenBook book)
        {
            book.LookYuWenBook();
        }

    }

然后是语文书类YuWenBook类:

public class YuWenBook
    {

        public void LookYuWenBook()
        {
            Console.WriteLine("看语文书");
        }

    }

最后,我们开始调用:

class Program
    {
        static void Main(string[] args)
        {
            YuWenBook book = new YuWenBook();
            Student student = new Student();
            student.DoSomething(book);

        }
    }

以上程序都没有错,new一个语文的对象,然后new一个学生对象,最后把语文对象赋值到学生的book中。完成了学生看书。

但是,这是不好扩展的,抛离了面向对象的低耦合,高内聚的思想。因为,如果,我们要添加学生看英语书,那怎么添加呢?

首先,在Student类中添加方法DoSomething(EnglishBook book); 然后再实现EnghlishBook类的LookEnglishBook方法。

最后调用,变成:

static void Main(string[] args)
        {
            YuWenBook book = new YuWenBook();
            Student student = new Student();
            student.DoSomething(book);

            //学生看英语书
            EnglishBook englishBook = new EnglishBook();
            student.DoSomething(englishBook);

        }

一看,就知道不好扩展。因为已经修改了Student类中代码(增加了方法)。怎么才算好扩展呢,那么要聊起与开闭原则有关系了。对修改关闭,对扩展开放。所以我们尽量的不要修改Student类中的代码。所以,我们增加一个接口,叫IBook:

public interface IBook
    {

        void LookBook();

    }

然后,英语、语文各自继承IBook:

    public class EnglishBook: IBook
    {
        public void LookBook()
        {
            Console.WriteLine("看英语书");
        }

    }

    public class YuWenBook:IBook
    {

        public void LookBook()
        {
            Console.WriteLine("看语文书");
        }

    }

再修改一下Student的方法,接收IBook参数,变成:

public class Student
    {

        public void DoSomething(IBook book)
        {
            book.LookBook();
        }

    }

最后,看我们是怎么调用的:

static void Main(string[] args)
        {
            IBook book = new YuWenBook();
            Student student = new Student();
            student.DoSomething(book);

            //学生看英语书
            book = new EnglishBook();
            student.DoSomething(book);

        }

看看,是不是可以很方面的扩展? 为什么这样说呢?

因为当我们再添加一个学生看数学书的时候,我们只需要添加一个数学书类来继承IBook,然后实现LookBook方法。最后我们用IBook对象来调用数学书类就可以了。可以看出,Student不用做任何修改,IBook也是。只需做相应的实现与调用即可。

3)小结

到此,介绍与例子到此结束了,我们可以看到面向对象的设计是多么的广、深。从一些小小的例子、甚至身边发生的事,都可以联想到面向对象的设计。要掌握面向对象,首先要掌握其原则。

其他链接:

开放封闭原则(开闭原则)

单一职责原则

依赖倒置原则

接口隔离原则

里氏替换原则

迪米特法则

此文转发,请注明出处,谢谢。

可以关注本人的公众号,多年经验的原创文章共享给大家。

原文地址:https://www.cnblogs.com/lonelyxmas/p/10217567.html

时间: 2024-10-20 22:20:49

面向对象原则之一 依赖倒置原则的相关文章

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

一.概念: 依赖倒置原则英文缩写DIP(Dependence Inversion Principle)原始定义:High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions. 翻译过来就三层含义

6大设计原则之依赖倒置原则

依赖倒置原则: 包含三层含义: 高层模块不应该依赖低层模块,二者应该依赖抽象 抽象不应该依赖细节 细节应该依赖抽象 再精简些就是:其核心是面向接口编程 抽象:即抽象类和接口,抽象是对实现的约束,对依赖而言也是一种契约 细节:即具体的实现类,实现接口或继承抽象类所产生的类 依赖倒置就是通过抽象使各个类或模块间实现彼此独立,互不影响,实现模块间的松耦合. 依赖的三种实现方式: 构造函数注入 Setter依赖注入 接口注入 6大设计原则之依赖倒置原则

Java的开发—面向对象的7大原则之依赖倒置原则(一)

一.定义: 依赖倒置原则(Dependecy Inversion Principle) 原文为: High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions 三层定义: 1.高层模块不应该依赖底层模

设计原则之依赖倒置原则

定义:高层模块不应该依赖低层模块,二者都应该依赖其抽象:抽象不应该依赖细节:细节应该依赖抽象. 问题:类A直接依赖类B,假如要将类A改为依赖类C,则必须通过修改类A的代码来达成.这种场景下,类A一般是高层模块, 负责复杂的业务逻辑:类B和类C是低层模块,负责基本的原子操作:假如修改类A,会给程序带来不必要的风险. 解决:将类A修改为依赖接口I,类B和类C各自实现接口I,类A通过接口I间接与类B或者类C发生联系,则会大大降低修改类A的几率. 举个栗子:讲一个读者读书的故事... 1. 新建一个类B

深入理解JavaScript系列(22):S.O.L.I.D五大原则之依赖倒置原则DIP

前言 本章我们要讲解的是S.O.L.I.D五大原则JavaScript语言实现的第5篇,依赖倒置原则LSP(The Dependency Inversion Principle ). 英文原文:http://freshbrewedcode.com/derekgreer/2012/01/22/solid-javascript-the-dependency-inversion-principle/ 依赖倒置原则 依赖倒置原则的描述是: A. High-level modules should not

设计模式六大原则(三)——依赖倒置原则

依赖倒置原则 定义: 高层模块不应该依赖低层模块,二者都应该依赖其抽象:抽象不应该依赖细节:细节应该依赖抽象. 问题由来: 类A直接依赖类B,假如要将类B改为依赖类C,则必须通过修改类A的代码来达成.这种场景下,类A一般是高层模块,负责复杂的业务逻辑:类B和类C是低层模块,负责基本的原子操作:假如修改类A,会给程序带来不必要的风险. 解决方案: 将类A修改为依赖接口I,类B和类C各自实现接口I,类A通过接口I间接与类B或者类C发生联系,则会大大降低修改类A的几率. 依赖倒置原则基于这样一个事实:

面向对象设计原则之四:依赖倒置原则

依赖倒置原则 所谓依赖倒置原则(Dependence Inversion Principle )就是要依赖于抽象,不要依赖于具体.简单的说就是对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合. 面向过程的开发,上层调用下层,上层依赖于下层,当下层剧烈变化时,上层也要跟着变化,这就会导致模块的复用性降低而且大大提高了开发的成本. 面向对象的开发很好的解决了这个问题,一般的情况下抽象的变化概率很小,让用户程序依赖于抽象,实现的细节也依赖于抽象.即使实现细节不断变化,只要抽象不变

面向对象设计原则四:依赖倒置原则

依赖倒置原则(DIP)        定义:高层模块不应该依赖底层模块,两者都应该依赖其抽象:抽象不应该依赖细节:细节应该依赖抽象. 好处:稳定性.可维护性.可扩展性. 概述:DI就是依赖倒置的意思,也可称为控制反转,我们以前编写结构化的程序当中,也就是C语言这样的语言时,高层模块依赖于底层模块,也就是调用者和被调用者的关系,调用者要依赖于被调用者,被调用者编写的一些功能和服务,会影响高层,一旦底层发生了变化,也就是被调用者发生了变化,就直接影响了高层也就是调用者.这样的设计,很难保证他的稳定性

设计模式六大原则(3)--依赖倒置原则

定义: 高层次的模块不应该依赖于低层次的模块,两者都应该依赖于抽象接口:抽象接口不应该依赖于具体实现.而具体实现则应该依赖于抽象接口.依赖倒置原则英文全称为Dependence Inversion Principle,简称为DIP. 问题由来: 类A直接依赖类B,假如要将类A改为依赖类C,则必须通过修改类A的代码来达成.这种场景下,类A一般是高层模块,负责复杂的业务逻辑:类B和类C是低层模块,负责基本的原子操作:假如修改类A,会给程序带来不必要的风险. 解决方案: 将类A修改为依赖接口I,类B和