设计模式的目的

1、代码重用性

2、可读性

3、可扩展性（增加功能时，对原来的功能没有影响）

4、可靠性（增加功能时，对原来的功能没有影响）

5、高内聚，低耦合

单一职责原则

一个类应该只负责一项职责

如：类 A 负责两个不同职责：职责 1，职责 2。

当职责 1 需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2

注意：

  • 降低类的复杂度，一个类负责一个职责
  • 提高类的可读性
  • 降低变更的风险

只有类中方法数量足够少时，可以在方法级别保持单一职责原则

​ 0

​ 0

​ 0

接口隔离的原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

类A和类C只需要依赖接口1的一部分接口，而不需要实现全部，所以可以将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)，类 A 和类 C 分别与他们需要的接口建立依赖关系

​ 0

​ 0

依赖倒转原则

1）高层模块不应该依赖底层模块，二者都应该依赖其抽象

2）抽象不应该依赖细节，细节应该依赖抽象

3）核心思想：面向接口编程

三种方式：接口传递，构造方法传递，setter方法传递

​ 0

​ 0

里氏替换原则

继承给程序设计带来便利也带来了弊端：

  • 使用继承会给程序带来侵入性
  • 可移植性降低
  • 增加对象间的耦合
  • 当这个类要修改时，必须考虑到所有的子类

正确使用继承：

  • 使用继承时，在子类中尽量不要重写父类的方法
  • 在适当的情况，可以使用聚合，组合，依赖来解决

解决方法：让原来的子类和父类都继承一个更通俗的基类，将原有的继承关系去掉，采用聚合，组合，依赖等关系来代替

​ 0

​ 0

开闭原则 （最基础，最重要）

比如一个类，模块和函数一个对扩展开发（对提供方），对修改关闭（对使用方）。

当软件需要变化，尽量通过扩展代码，而不是通过修改已有代码的方法实现

案例：

如果需要增加新的功能，绘制别的图形，需要在使用方处修改代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class Ocp {
   public static void main(String[] args) {
      //使用看看存在的问题
      GraphicEditor graphicEditor = new GraphicEditor();
      graphicEditor.drawShape(new Rectangle());
      graphicEditor.drawShape(new Circle());
      graphicEditor.drawShape(new Triangle());
   }
}
//这是一个用于绘图的类 [使用方]
class GraphicEditor {
   //接收Shape对象，然后根据type，来绘制不同的图形
   public void drawShape(Shape s) {
      if (s.m_type == 1)
         drawRectangle(s);
      else if (s.m_type == 2)
         drawCircle(s);
      else if (s.m_type == 3)
         drawTriangle(s);
   }
   //绘制矩形
   public void drawRectangle(Shape r) {
      System.out.println(" 绘制矩形 ");
   }
   //绘制圆形
   public void drawCircle(Shape r) {
      System.out.println(" 绘制圆形 ");
   }
   //绘制三角形
   public void drawTriangle(Shape r) {
      System.out.println(" 绘制三角形 ");
   }
}
//Shape类，基类
class Shape {
   int m_type;
}
class Rectangle extends Shape {
   Rectangle() {
      super.m_type = 1;
   }
}
class Circle extends Shape {
   Circle() {
      super.m_type = 2;
   }
}
//新增画三角形
class Triangle extends Shape {
   Triangle() {
      super.m_type = 3;
   }
}

改进：

创建一个抽象类Shape，提供一个抽象方法drow，然后让子类去继承该抽象方法，重写该抽象方法，当需要增加新的功能的时候，只需要创建一个新的类去继承抽象方法并重写即可，无需对使用方代码进行改动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public class Ocp {
   public static void main(String[] args) {
      //使用看看存在的问题
      GraphicEditor graphicEditor = new GraphicEditor();
      graphicEditor.drawShape(new Rectangle());
      graphicEditor.drawShape(new Circle());
      graphicEditor.drawShape(new Triangle());
      graphicEditor.drawShape(new OtherGraphic());
   }
}
//这是一个用于绘图的类 [使用方]
class GraphicEditor {
   //接收Shape对象，调用draw方法
   public void drawShape(Shape s) {
      s.draw();
   }
}
//Shape类，基类
abstract class Shape {
   int m_type;
   public abstract void draw();//抽象方法
}
class Rectangle extends Shape {
   Rectangle() {
      super.m_type = 1;
   }
   @Override
   public void draw() {
      System.out.println(" 绘制矩形 ");
   }
}

class Circle extends Shape {
   Circle() {
      super.m_type = 2;
   }
   @Override
   public void draw() {
      System.out.println(" 绘制圆形 ");
   }
}
//新增画三角形
class Triangle extends Shape {
   Triangle() {
      super.m_type = 3;
   }
   @Override
   public void draw() {
      System.out.println(" 绘制三角形 ");
   }
}
//新增一个图形
class OtherGraphic extends Shape {
   OtherGraphic() {
      super.m_type = 4;
   }
   @Override
   public void draw() {
      System.out.println(" 绘制其它图形 ");
   }
}

迪米特法则 （最少知道原则）

一个对象应该对其他对象保持最少的了解

每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，则这两个对象之间是朋友关系

其中，出现成员变量，方法参数，方法返回值中的类为直接的朋友

迪米特法则只要要求降低类间（对象间）耦合关系，并不是要求完全没有依赖关系

合成复用原则

尽量使用合成或者聚合的方式，而不是使用继承

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起

针对接口编程，而不是针对具体实现编程

松耦合设计

​ 0

待整理