Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1104014
  • 博文数量: 695
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4027
  • 用 户 组: 普通用户
  • 注册时间: 2013-11-20 21:22
文章分类

全部博文(695)

文章存档

2018年(18)

2017年(74)

2016年(170)

2015年(102)

2014年(276)

2013年(55)

分类: Java

2016-07-08 11:01:38

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

依赖倒置原则

      所谓依赖倒置原则(Dependence Inversion Principle )就是要依赖于抽象,不要依赖于具体。简单的说就是对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。

      面向过程的开发,上层调用下层,上层依赖于下层,当下层剧烈变化时,上层也要跟着变化,这就会导致模块的复用性降低而且大大提高了开发的成本。

面向对象的开发很好的解决了这个问题,一般的情况下抽象的变化概率很小,让用户程序依赖于抽象,实现的细节也依赖于抽象。即使实现细节不断变化,只要抽象不变,客户程序就不需要变化。这大大降低了客户程序域实现细节的耦合度。

      比如一个合资汽车公司现在要求开发一个自动驾驶系统,只要汽车上安装上这个系统,就可以实现无人驾驶,该系统可以在福特车系列和本田车系列上使用。面向过程的结构图:

                                                                 

实现代码如下:

public class HondaCar

    {

        public void Run() { Console.WriteLine("本田车启动了!"); }

        public void Turn() { Console.WriteLine("本田车拐弯了!"); }

        public void Stop() { Console.WriteLine("本田车停止了!"); }

    }

    public class FordCar

    {

        public void Run() { Console.WriteLine("福特车启动了!"); }

        public void Turn() { Console.WriteLine("福特车拐弯了!"); }

        public void Stop() { Console.WriteLine("福特车停止了!"); }

    }

    public class AutoSystem

    {

        public enum CarType{ Ford,Fonda}

        private HondaCar hondcar=new HondaCar();

        private FordCar fordcar=new FordCar();

        private CarType type;

        public AutoSystem(CarType carType)

        {

            this.type = carType;

        }

        public void RunCar()

        {

            if (this.type == CarType.Fonda)

            {

                hondcar.Run();

            }

            else if (this.type == CarType.Ford)

            {

                fordcar.Run();

            }

        }

        public void StopCar()

        {

            if (this.type == CarType.Fonda)

            {

                hondcar.Stop();

            }

            else if (this.type == CarType.Ford)

            {

                fordcar.Stop();

            }

        }

        public void TurnCar()

        {

            if (this.type == CarType.Fonda)

            {

                hondcar.Turn();

            }

            else if (this.type == CarType.Ford)

            {

                fordcar.Turn();

            }

        }

    }

显然这个实现代码也可满足现在的需求。

但是如何现在公司业务规模扩大了,该自动驾驶系统还要把吉普车也兼容了。这些就需要修改AutoSystem类如下:

public class AutoSystem

    {

        public enum CarType{ Ford,Fonda,Jeep}

        private HondaCar hondcar=new HondaCar();

        private FordCar fordcar=new FordCar();

        private Jeep jeep = new Jeep();

        private CarType type;

        public AutoSystem(CarType carType)

        {

            this.type = carType;

        }

        public void RunCar()

        {

            if (this.type == CarType.Fonda)

            {

                hondcar.Run();

            }

            else if (this.type == CarType.Ford)

            {

                fordcar.Run();

            }

            else if (this.type == CarType.Jeep)

            {

                jeep.Run();

            }

        }

        public void StopCar()

        {

            if (this.type == CarType.Fonda)

            {

                hondcar.Stop();

            }

            else if (this.type == CarType.Ford)

            {

                fordcar.Stop();

            }

            else if (this.type == CarType.Jeep)

            {

                jeep.Stop();

            }

        }

        public void TurnCar()

        {

            if (this.type == CarType.Fonda)

            {

                hondcar.Turn();

            }

            else if (this.type == CarType.Ford)

            {

                fordcar.Turn();

            }

            else if (this.type == CarType.Jeep)

            {

                jeep.Turn();

            }

        }

    }

        通过代码分析得知,上述代码也确实满足了需求,但是软件是不断变化的,软件的需求也是变化的,如果将来业务又扩大了,该自动驾驶系统还有能实现通用、三 菱、大众汽车,这样我们不得不又要修改AutoSystem类了。这样会导致系统越来越臃肿,越来越大,而且依赖越来越多低层模块,只有低层模块变 动,AutoSystem类就不得不跟着变动,导致系统设计变得非常脆弱和僵硬。

       导致上面所述问题一个原因是,含有高层策略的模块,如AutoSystem模块,依赖于它所控制的低层的具体细节的模块(如FordCar和 HondaCar)。如果能使AutoSystem模块独立于它所控制的具体细节,而是依赖抽象,那么我们就可以服用它了。这就是面向对象中的“依赖倒 置”机制。如下类图:

                                                                        

 

实现代码如下:

public interface ICar

    {

        void Run();

        void Stop();

        void Turn();

    }

    public class HondaCar:ICar

    {

        public void Run() { Console.WriteLine("本田车启动了!"); }

        public void Turn() { Console.WriteLine("本田车拐弯了!"); }

        public void Stop() { Console.WriteLine("本田车停止了!"); }

    }

    public class FordCar :ICar

    {

        public void Run() { Console.WriteLine("福特车启动了!"); }

        public void Turn() { Console.WriteLine("福特车拐弯了!"); }

        public void Stop() { Console.WriteLine("福特车停止了!"); }

    }

    public class Jeep:ICar

    {

        public void Run() { Console.WriteLine("福特车启动了!"); }

        public void Turn() { Console.WriteLine("福特车拐弯了!"); }

        public void Stop() { Console.WriteLine("福特车停止了!"); }

    }

    public class AutoSystem

    {

        private ICar car;

        public AutoSystem(ICar car)

        {

            this.car = car;

        }

        public void RunCar()

        {

            this.car.Run();

        }

        public void StopCar()

        {

            this.car.Stop();

        }

        public void TurnCar()

        {

            this.car.Turn();

        }

    }

     现在Autosystem系统依赖于ICar这个抽象,而与具体的实现细节HondaCar:和FordCar无关,所以实现细节的变化不会影响AutoSystem.对于实现细节只要实现ICar即可。即实现细节依赖于ICar抽象。

     综上所述:一个应用中的重要策略决定及业务 正是在这些高层的模块中。也正是这些模块包含这应用的特性。但是,当这些模块依赖于低层模块时,低层模块的修改比较将直接影响到他们,迫使它们也改变。这种情况是荒谬的。

     应该是处于高层的模块去迫使那些低层的模块发生改变。处于高层的模块应优先于低层的模块。无论如何高层模块也不应该依赖于低层模块。而且我们想能够复用的是高层的模块,只有高层模块独立于低层模块时,复用才有可能。

      总之,高层次的模块不应该依赖于低层次的模块,它们都应该依赖于抽象。抽象不应该依赖于具体,具体应该依赖于抽象。

阅读(401) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~