面向对象的设计原则

一·、依赖倒置原则(DIP)

高层模块(稳定)不应该依赖于低层模块(变化),二者都应该依赖于抽象(稳定)。

抽象(稳定)不应该依赖于实现细节(变化),实现细节(变化)应该依赖于抽象(稳定)。

怎么理解这两句话呢?我们看一个画图的例子。

 1 class DrawCircle {
 2 
 3     public void draw() {
 4         System.out.println("画一个圆");
 5     }
 6 }
 7 
 8 
 9 class DrawLine {
10 
11     public void draw() {
12         System.out.println("画一个线");
13     }
14 }
15 
16 
17 public class MainFrame {
18 
19     public static void main(String[] args) {
20         DrawCircle circle = new DrawCircle();
21         circle.draw();
22         //或者我们要画一条线
23         DrawLine drawLine = new DrawLine();
24         drawLine.draw();
25     }
26 }

 其中MainFrame类就是所说的高层模块,DrawCircle和DrawLine类相对于MainFrame就是低层模块。低层模块是变化的,我们要画圆就要new一个画圆的类,要画线就要new一个画线的类等等。底层的变化影响到了高层的改变,就像盖二层小楼一样,当我们在第一层又增加了一个套间,需要导致第二层也要跟着做出变化,这显然是不合适的。这样的变化代价是更大的。

正确的做法是低层和高层都依赖于抽象的类,如下面代码所示:

 1 public interface DrawPicture {
 2     void draw();
 3 }
 4 
 5 public class DrawLine implements DrawPicture {
 6 
 7     public void draw() {
 8         System.out.println("画一个线");
 9     }
10 }
11 
12 public class DrawCircle implements DrawPicture {
13 
14     public void draw() {
15         System.out.println("画一个圆");
16     }
17 }
18 
19 public class MainFrame {
20     private DrawPicture  drawPicture;
21     MainFrame (DrawPicture  drawPicture) {
22         this.drawPicture = drawPicture;
23     }
24 
25     public void frameDraw () {
26         drawPicture.draw();
27     }
28 }

MainFrame、DrawLine和DrawCircle都依赖于DrawPicture接口,这就是所说的二者都依赖于抽象。

通过这种方式,我们就实现了隔离变化。稳定的部分不依赖变化的部分,让变化的部分依赖稳定的部分,这样即使变化的部分发生变化,对稳定的部分也不会有影响。

二、开放封闭原则(OCP)

对扩展开放,对修改封闭。

类模块应该是可扩展的,但是不可修改。

还是用上面的那个例子,我先现在需要画一个新的图形——五角星,如果我们采用第一种方式,那么我们需要新建一个画五角星的类,然后修改MainFrame,在代码中引入画五角星的类,这样会导致MainFrame跟着修改。如果我们采用第二种方式,那么我们同样需要增加一个画五角星的类,但是MainFrame类不需要再进行改变了,这就是开闭原则。

三、单一职责原则(SRP)

一个类应该仅有一个引起它变化的原因,变化的方向隐含着类的责任。

四、Liskov替换原则(LSP)

子类必须能够替换它们的基类(IS-A)

五、接口隔离原则(ISP)

不应该强迫客户程序依赖它们不用的方法,接口应该小而完备。不要把不必要的方法开放出去。

六、优先使用组合,而不是类的继承

类继承通常为“白箱复用”,组合通常为“黑箱复用”。继承在某种程度上破坏了封装性,子类父类耦合度高。而对象的组合则只要求被组合的对象具有良好定义的接口,耦合度低。

七、封装变化点

使用封装来创建对象之间的分界层,让设计者可以在分界层的一侧进行修改,而不会对另一侧产生不良的影响,从而实现代码的松耦合。

八、针对接口编程,而不是针对实现编程

不将变量类型声明为一个具体类,而是声明为某个接口。

客户程序无需知道业务程序的具体类型,只需要知道相应的接口,减少系统内部各部分的依赖关系,从而实现高内聚,低耦合。

 

 

 

 

原文地址:https://www.cnblogs.com/ChenBingJie123/p/14323166.html