设计模式七大原则解读（一）-阿里云开发者社区

设计模式的目的

编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好

1) 代码重用性 (即：相同功能的代码，不用多次编写)

2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解)

3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)

4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)

5) 使程序呈现高内聚，低耦合的特性

分享金句：

设计模式包含了面向对象的精髓， “懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要”Scott Mayers 在其巨著《Effective C++》就曾经说过：C++老手和 C++新手的区别就是前者手背上有很多伤疤

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)

设计模式常用的七大原则有:

1) 单一职责原则

2) 接口隔离原则

3) 依赖倒转(倒置)原则

4) 里氏替换原则

5) 开闭原则

6) 迪米特法则

7) 合成复用原则

单一职责原则

基本介绍

对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2

应用实例

1. public class SingleResponsibility1 {
2. public static void main(String[] args) {
3. Vehicle vehicle = new Vehicle();
4.         vehicle.run("摩托车");
5.         vehicle.run("汽车");
6.         vehicle.run("飞机");
7.     }
8. }
9. //交通工具类
10. 
11. class Vehicle {
12. public void run(String vehicle) {
13.         System.out.println(vehicle + " 在公路上运行....");
14.     }
15. }

1. 在上面的方式的 run 方法中，违反了单一职责原则

2. 解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可

1. public class SingleResponsibility2 {
2. public static void main(String[] args) {
3. RoadVehicle roadVehicle = new RoadVehicle();
4.         roadVehicle.run("摩托车");
5.         roadVehicle.run("汽车");
6. AirVehicle airVehicle = new AirVehicle();
7.         airVehicle.run("飞机");
8.     }
9. }
10. 
11. //方案 2 的分析
12. //1. 遵守单一职责原则
13. //2. 但是这样做的改动很大，即将类分解，同时修改客户端
14. //3. 改进：直接修改 Vehicle 类，改动的代码会比较少=>方案 3
15. class RoadVehicle {
16. public void run(String vehicle) {
17.         System.out.println(vehicle + "公路运行");
18.     }
19. }
20. 
21. class AirVehicle {
22. public void run(String vehicle) {
23.         System.out.println(vehicle + "天空运行");
24.     }
25. }
26. 
27. class WaterVehicle {
28. public void run(String vehicle) {
29.         System.out.println(vehicle + "水中运行");
30.     }
31. }

1. 遵守单一职责原则

2. 但是这样做的改动很大，即将类分解，同时修改客户端

3. 改进：直接修改 Vehicle 类，改动的代码会比较少=>方案 3

1. public class SingleResponsibility3 {
2. public static void main(String[] args) {
3. Vehicle2 vehicle2 = new Vehicle2();
4.         vehicle2.run("汽车");
5.         vehicle2.runWater("轮船");
6.         vehicle2.runAir("飞机");
7.     }
8. }
9. 
10. class Vehicle2 {
11. public void run(String vehicle) {
12. //处理
13.         System.out.println(vehicle + " 在公路上运行....");
14.     }
15. 
16. public void runAir(String vehicle) {
17.         System.out.println(vehicle + " 在天空上运行....");
18.     }
19. 
20. public void runWater(String vehicle) {
21.         System.out.println(vehicle + " 在水中行....");
22.     }
23. //方法 2.
24. //..
25. //..
26. //...
27. }

1.这种修改方法没有对原来的类做大的修改，只是增加方法

2.这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责

注意事项和细节

单一职责原则注意事项和细节：

1) 降低类的复杂度，一个类只负责一项职责。

2) 提高类的可读性，可维护性

3) 降低变更引起的风险

4) 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

接口隔离原则(Interface Segregation Principle)

基本介绍

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

类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法。

按隔离原则应当这样处理：
将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

应用实例

没有使用接口隔离原则代码

1. public class Segregation1 {
2. public static void main(String[] args) {
3. 
4.     }
5. }
6. 
7. interface Interface1 {
8. void operation1();
9. 
10. void operation2();
11. 
12. void operation3();
13. 
14. void operation4();
15. 
16. void operation5();
17. }
18. 
19. class B implements Interface1 {
20. public void operation1() {
21.         System.out.println("B 实现了 operation1");
22.     }
23. 
24. public void operation2() {
25.         System.out.println("B 实现了 operation2");
26.     }
27. 
28. public void operation3() {
29.         System.out.println("B 实现了 operation3");
30.     }
31. 
32. public void operation4() {
33.         System.out.println("B 实现了 operation4");
34.     }
35. 
36. public void operation5() {
37.         System.out.println("B 实现了 operation5");
38.     }
39. }
40. 
41. class D implements Interface1 {
42. public void operation1() {
43.         System.out.println("D 实现了 operation1");
44.     }
45. 
46. public void operation2() {
47.         System.out.println("D 实现了 operation2");
48.     }
49. 
50. public void operation3() {
51.         System.out.println("D 实现了 operation3");
52.     }
53. 
54. public void operation4() {
55.         System.out.println("D 实现了 operation4");
56.     }
57. 
58. public void operation5() {
59.         System.out.println("D 实现了 operation5");
60.     }
61. }
62. 
63. class A { //A 类通过接口 Interface1 依赖(使用) B 类，但是只会用到 1,2,3 方法
64. public void depend1(Interface1 i) {
65.         i.operation1();
66.     }
67. 
68. public void depend2(Interface1 i) {
69.         i.operation2();
70.     }
71. 
72. public void depend3(Interface1 i) {
73.         i.operation3();
74.     }
75. }
76. 
77. class C { //C 类通过接口 Interface1 依赖(使用) D 类，但是只会用到 1,4,5 方法
78. public void depend1(Interface1 i) {
79.         i.operation1();
80.     }
81. 
82. public void depend4(Interface1 i) {
83.         i.operation4();
84.     }
85. 
86. public void depend5(Interface1 i) {
87.         i.operation5();
88.     }
89. }

应传统方法的问题和使用接口隔离原则改进

1) 类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法

2) 将接口 Interface1 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

3) 接口 Interface1 中出现的方法，根据实际情况拆分为三个接口

1. public class Segregation1 {
2. public static void main(String[] args) {
3. // TODO Auto-generated method stub
4. // 使用一把
5. A a = new A();
6.         a.depend1(new B()); // A 类通过接口去依赖 B 类
7.         a.depend2(new B());
8.         a.depend3(new B());
9. C c = new C();
10.         c.depend1(new D()); // C 类通过接口去依赖(使用)D 类
11.         c.depend4(new D());
12.         c.depend5(new D());
13.     }
14. }
15. 
16. // 接口 1
17. interface Interface1 {
18. void operation1();
19. }
20. 
21. // 接口 2
22. interface Interface2 {
23. void operation2();
24. 
25. void operation3();
26. }
27. 
28. // 接口 3
29. interface Interface3 {
30. void operation4();
31. 
32. void operation5();
33. }
34. 
35. class B implements Interface1, Interface2 {
36. public void operation1() {
37.         System.out.println("B 实现了 operation1");
38.     }
39. 
40. public void operation2() {
41.         System.out.println("B 实现了 operation2");
42.     }
43. 
44. public void operation3() {
45.         System.out.println("B 实现了 operation3");
46.     }
47. }
48. 
49. class D implements Interface1, Interface3 {
50. public void operation1() {
51.         System.out.println("D 实现了 operation1");
52.     }
53. 
54. public void operation4() {
55.         System.out.println("D 实现了 operation4");
56.     }
57. 
58. public void operation5() {
59.         System.out.println("D 实现了 operation5");
60.     }
61. }
62. 
63. class A { // A 类通过接口 Interface1,Interface2 依赖(使用) B 类，但是只会用到 1,2,3 方法
64. public void depend1(Interface1 i) {
65.         i.operation1();
66.     }
67. 
68. public void depend2(Interface2 i) {
69.         i.operation2();
70.     }
71. 
72. public void depend3(Interface2 i) {
73.         i.operation3();
74.     }
75. }
76. 
77. class C { // C 类通过接口 Interface1,Interface3 依赖(使用) D 类，但是只会用到 1,4,5 方法
78. public void depend1(Interface1 i) {
79.         i.operation1();
80.     }
81. 
82. public void depend4(Interface3 i) {
83.         i.operation4();
84.     }
85. 
86. public void depend5(Interface3 i) {
87.         i.operation5();
88.     }
89. }

设计模式七大原则解读（一）

设计模式的目的

单一职责原则

基本介绍

应用实例

注意事项和细节

接口隔离原则(Interface Segregation Principle)

基本介绍

应用实例

应传统方法的问题和使用接口隔离原则改进

热门文章

最新文章

相关课程

相关电子书