设计模式6大原则-依赖倒置原则

设计模式6大原则-依赖倒置原则

定义:
(1) 高层模块不应该依赖低层模块,两者都应该依赖其抽象
(2) 抽象不应该依赖细节
(3) 细节应该依赖抽象

如果高层模块依赖于低层模块,当低层模块发生变化需要改动时,会导致高层模块跟着修改。
抽象和细节又是什么?
抽象:接口或者抽象类
细节:就是实现类

优点:
(1) 降低类间的耦合
(2) 提高系统的稳定性
(3) 减少并行开发引起的风险
(4) 提高代码的可读性和可维护性

实现方法:
(1) 每个类尽量提供接口或抽象,或者两者都具备
(2) 变量的表面类型尽量是接口或者抽象类
(3) 任何类都不应该从具体类派生
(4) 继承时尽量遵循里氏替换原则

下面以一个实例展示依赖倒置的实现
饭店有不同的菜肴,来自五湖四海的顾客喜欢吃的家乡菜也不一样,如何优雅地实现顾客与菜肴的设计??
将菜肴抽象出一个接口,具体菜肴类实现该接口
顾客抽象出一个抽象类,具体顾客类继承抽象顾客类,抽象顾客类填加对菜肴抽象接口的引用

类图如下
在这里插入图片描述
菜肴接口

    // 菜肴接口
    public interface IFood
    {
        string GetName();
    }

具体菜肴类

    // 川菜麻婆豆腐
    public class MaPoDouFu : IFood
    {
        public MaPoDouFu()
        {
        }

        public string GetName()
        {
            return "川菜麻婆豆腐";
        }
    }

    // 鲁菜红焖大虾
    public class HongMenDaXia : IFood
    {
        public HongMenDaXia()
        {
        }

        public string GetName()
        {
            return "红焖大虾";
        }
    }

抽象顾客类

    // 顾客抽象类
    public abstract class Customer
    {
        // 菜肴引用
        public List<IFood> foodList = new List<IFood>();

        // 添加菜肴
        public virtual void SetFood(IFood food)
        {
            foodList.Add(food);
        }

        public abstract void Eat();
    }

具体客户类

    // 山东顾客
    public class ShanDongCustomer : Customer
    {
        public override void Eat()
        {
            Console.WriteLine("我是山东的,我要吃山东的家乡菜");
            foreach(var food in foodList)
            {
                Console.WriteLine(food.GetName() + "\n");
            }
        }
    }

    // 四川顾客
    public class SiChuanCustomer : Customer
    {
        public override void SetFood(IFood food)
        {
            foodList.Add(food);
        }

        public override void Eat()
        {
            Console.WriteLine("我是四川的,我要吃四川的家乡菜");
            foreach (var food in foodList)
            {
                Console.WriteLine(food.GetName() + "\n");
            }
        }
    }

代码调用如下

    public class Client
    {
        public Client()
        {
            MaPoDouFu maPoDouFu = new MaPoDouFu();
            SiChuanCustomer siChuanCustomer = new SiChuanCustomer();
            siChuanCustomer.SetFood(maPoDouFu);
            siChuanCustomer.Eat();

            HongMenDaXia hongMenDaXia = new HongMenDaXia();
            ShanDongCustomer shanDongCustomer = new ShanDongCustomer();
            shanDongCustomer.SetFood(hongMenDaXia);
            shanDongCustomer.Eat();
        }
    }

运行结果如下
在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SOLID原则中的依赖倒置原则(Dependency Inversion Principle,DIP)是指高层模块不应该依赖底层模块,二者都应该依赖于抽象接口;抽象接口不应该依赖于具体实现,而具体实现应该依赖于抽象接口。 简单来说,DIP原则就是通过接口来解耦高层模块和底层模块之间的依赖关系,使得系统更加灵活、可维护、可扩展。在设计和开发过程中,我们应该遵循DIP原则,尽可能使用接口或抽象类来定义模块之间的依赖关系,而不是直接依赖具体实现类。 举个例子,假设我们正在开发一个电商系统。我们有一个OrderService类,它依赖于一个底层模块的OrderDao类来实现订单数据的持久化。如果我们直接在OrderService类中实例化OrderDao对象,那么OrderService类就与OrderDao类紧密耦合,如果我们需要更换一种不同的数据持久化方案,那么就需要修改OrderService类的代码,违反了开闭原则(Open Close Principle,OCP)。 为了遵循DIP原则,我们可以先定义一个抽象的OrderDao接口,然后让OrderService类依赖于OrderDao接口。底层模块的具体实现类可以实现OrderDao接口,这样就可以实现数据持久化的功能,同时也可以轻松地更换不同的数据持久化方案,不需要修改OrderService类的代码。 总之,DIP原则设计模式中非常重要的原则之一,它可以帮助我们构建更加灵活、可维护、可扩展的系统。在实际开发中,我们应该尽可能地遵循DIP原则,使用接口或抽象类来定义模块之间的依赖关系,降低模块之间的耦合度,提高系统的可维护性和可扩展性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值