依赖倒置原则 个人理解

依赖倒置原则核心:

上层模块不应该依赖底层模块，它们都应该依赖于抽象。

抽象不应该依赖于细节，细节应该依赖于抽象。

 

OR
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

 

 

上层模块是我们要做什么,下层模块是怎么做

例如:Eat里面我们要吃什么就是所谓的上层 而面包类,包子类 就是下层模块,

 

例如我要实现一个吃面包过程

里面包含三个部分,一个是吃的什么,一个是开始吃的命令,还有一个是输出吃.

 public class Bread {
           public void Being_eaten()
            {
                Console.WriteLine("我是面包我被吃了");
            }
            
        }

        public class Eat {
            public void eat(Bread bread) {
                bread.Being_eaten();
            }

        }

        static void Main(string[] args)
        {
            //实例化面包
            Bread bread = new Bread();
            //实例化吃的方法
            Eat eat = new Eat();

            //开始吃
            eat.eat(bread);
            Console.ReadLine();
        }

 

ok上面是一个很完整的吃面包过程,那么这个时候,我不仅仅是想吃面包了,我还想吃包子怎么办?

 

        public class Bread {
           public void Being_eaten()
            {
                Console.WriteLine("我是面包我被吃了");
            }
            
        }
        public class Bun
        {
            public void Being_eaten()
            {
                Console.WriteLine("我是包子!!我被吃了");
            }

        }
        public enum Food
        {
            Bread, Bun
        }
        public class Eat {
            public void eat(Food _food) {
                if (_food == (Food)0)
                {
                    Bread bread = new Bread();
                    bread.Being_eaten();
                } else if (_food==(Food)1)
                {
                    Bun bun = new Bun();
                    bun.Being_eaten();
                }
            }

        }

        static void Main(string[] args)
        {
            //实例化面包
        //    Bread bread = new Bread();
            //实例化吃的方法
            Eat eat = new Eat();
            //开始吃
            eat.eat((Food)1);
            Console.ReadLine();
        }

 

看着用很轻松的解决了吃包子跟面包的问题,但是我们明显发现了Eat这个类因为要吃的东西变多所以做了很明显的改变,那我们现在吃包子跟面包,那如果我要吃满汉全席,是不是得写108个 else if??

所以我们需要依赖倒置的写法,这种方法不会破坏Eat这个动作.

 

 

你要怎么办?

 

   public interface IFood
        {
            void Being_eaten();
        }  

        public class Bread: IFood
        {
           public void Being_eaten()
            {
                Console.WriteLine("我是面包我被吃了");
            }
            
        }
        public class Bun: IFood
        {
            public void Being_eaten()
            {
                Console.WriteLine("我是包子!!我被吃了");
            }

        }

        public class Eat {
            public void eat(IFood Food) {
                Food.Being_eaten();
            }

        }

        static void Main(string[] args)
        {
            //实例化面包
            Bread bread = new Bread();
            //实例化吃包子方法
            Bun bun = new Bun();
            //实例化吃的方法
            Eat eat = new Eat();
            //开始吃
            eat.eat(bread);
            Console.ReadLine();
        }

通过上面的代码我们发现,吃什么已经不在是Eat这个类所需要考虑的事情了,外部无论有多少类要吃东西,对我们的Eat类都没有影响,这样我们程序在开发过程中才可以健壮.

 

转载于:https://www.cnblogs.com/zcl-cnblogs/p/9700895.html