设计模式七大原则

单一职责原则

  • 原则：对类来说，一个类应该只负责一个职责
  • 好处：
    1. 降低类的复杂度
    2. 提高类的可读性，可维护性
    3. 降低变更引起的风险
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"未使用单一职责原则"
public class SingleResponsibility1 {
	public static void main(String[] args) {
		Vehicle vehicle = new Vehicle();
		vehicle.run("摩托车");
		vehicle.run("汽车");
		vehicle.run("飞机");
	}
}
"交通工具类"
"1. 在方式1 的run方法中，违反了单一职责原则"
"2. 解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可"
class Vehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + " 在公路上运行....");
	}
}
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
"使用单一职责原则"
public class SingleResponsibility {
	public static void main(String[] args) {
		Vehicle2 vehicle2  = new Vehicle2();
		vehicle2.run("汽车");
		vehicle2.runWater("轮船");
		vehicle2.runAir("飞机");
	}
}

"分析"
"1. 这种修改方法没有对原来的类做大的修改，只是增加方法"
"2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责"
class Vehicle2 {
	public void run(String vehicle) {
		System.out.println(vehicle + " 在公路上运行....");
	}
	
	public void runAir(String vehicle) {
		System.out.println(vehicle + " 在天空上运行....");
	}
	
	public void runWater(String vehicle) {
		System.out.println(vehicle + " 在水中行....");
	}
}

接口隔离原则

  • 原则：客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上
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
62
63
64
65
66
67
68
69
"未使用接口隔离原则"
interface Interface1 {
	void operation1();
	void operation2();
	void operation3();
	void operation4();
	void operation5();
}

class B implements Interface1 {
	public void operation1() {
		System.out.println("B 实现了 operation1");
	}
	public void operation2() {
		System.out.println("B 实现了 operation2");
	}
	public void operation3() {
		System.out.println("B 实现了 operation3");
	}
	public void operation4() {
		System.out.println("B 实现了 operation4");
	}
	public void operation5() {
		System.out.println("B 实现了 operation5");
	}
}

class D implements Interface1 {
	public void operation1() {
		System.out.println("D 实现了 operation1");
	}
	
	public void operation2() {
		System.out.println("D 实现了 operation2");
	}
	public void operation3() {
		System.out.println("D 实现了 operation3");
	}
	public void operation4() {
		System.out.println("D 实现了 operation4");
	}
	public void operation5() {
		System.out.println("D 实现了 operation5");
	}
}

class A { "A 类通过接口Interface1 依赖(使用) B类，但是只会用到1,2,3方法"
	public void depend1(Interface1 i) {
		i.operation1();
	}
	public void depend2(Interface1 i) {
		i.operation2();
	}
	public void depend3(Interface1 i) {
		i.operation3();
	}
}
  
class C { "C 类通过接口Interface1 依赖(使用) D类，但是只会用到1,4,5方法"
	public void depend1(Interface1 i) {
		i.operation1();
	}
	public void depend4(Interface1 i) {
		i.operation4();
	}
	public void depend5(Interface1 i) {
		i.operation5();
	}
}
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
62
63
64
65
66
"使用接口隔离原则"
"接口1"
interface Interface1 {
	void operation1();
}

"接口2"
interface Interface2 {
	void operation2();
	void operation3();
}

"接口3"
interface Interface3 {
	void operation4();
	void operation5();
}

class B implements Interface1, Interface2 {
	public void operation1() {
		System.out.println("B 实现了 operation1");
	}
	public void operation2() {
		System.out.println("B 实现了 operation2");
	}
	public void operation3() {
		System.out.println("B 实现了 operation3");
	}

}

class D implements Interface1, Interface3 {
	public void operation1() {
		System.out.println("D 实现了 operation1");
	}
	public void operation4() {
		System.out.println("D 实现了 operation4");
	}
	public void operation5() {
		System.out.println("D 实现了 operation5");
	}
}

class A { "A 类通过接口Interface1,Interface2 依赖(使用) B类，但是只会用到1,2,3方法"
	public void depend1(Interface1 i) {
		i.operation1();
	}
	public void depend2(Interface2 i) {
		i.operation2();
	}
	public void depend3(Interface2 i) {
		i.operation3();
	}
}

class C { "C 类通过接口Interface1,Interface3 依赖(使用) D类，但是只会用到1,4,5方法"
	public void depend1(Interface1 i) {
		i.operation1();
	}
	public void depend4(Interface3 i) {
		i.operation4();
	}
	public void depend5(Interface3 i) {
		i.operation5();
	}
}

依赖倒转(倒置)原则

原则：

  1. 高层模块不应该依赖低层模块，二者都应该依赖抽象
  2. 抽象不应该依赖细节，细节应该依赖抽象
  3. 中心思想实现面向接口编程
  4. 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给实现类

设计理念

  • 相对于细节的多变性，抽象的东西要更稳定。以抽象为基础搭建的架构比以细节为基础搭建的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节指的是具体的实现类
  • 依赖倒转的三种方式：
    1. 接口传递
    2. 构造方法传递
    3. setter方式传递
  • 注意：
    1. 低层模块尽量都要有抽象类或接口
    2. 变量的声明类型尽量是抽象类或接口，这样在变量引用和实际对象间，就存在一个缓冲层，利于程序的扩展和优化
    3. 继承时遵循里式替换原则
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
"未使用依赖倒转原则"
public class DependecyInversion {
	public static void main(String[] args) {
		Person person = new Person();
		person.receive(new Email());
	}
}

class Email {
	public String getInfo() {
		return "电子邮件信息: hello,world";
	}
}

"完成Person接收消息的功能"
"方式分析"
"1. 简单，比较容易想到"
"2. 如果我们获取的对象是 微信，短信等等，则新增类，同时Perons也要增加相应的接收方法"
"3. 解决思路：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖"
"   因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就ok, 这样我们就符号依赖倒转原则"
class Person {
	public void receive(Email email ) {
		System.out.println(email.getInfo());
	}
}
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
"使用依赖倒转原则"
public class DependecyInversion {
	public static void main(String[] args) {
		"客户端无需改变"
		Person person = new Person();
		person.receive(new Email());		
		person.receive(new WeiXin());
	}
}

"定义接口"
interface IReceiver {
	public String getInfo();
}

class Email implements IReceiver {
	public String getInfo() {
		return "电子邮件信息: hello,world";
	}
}

"增加微信"
class WeiXin implements IReceiver {
	public String getInfo() {
		return "微信信息: hello,ok";
	}
}

"方式2"
class Person {
	"这里我们是对接口的依赖"
	public void receive(IReceiver receiver ) {
		System.out.println(receiver.getInfo());
	}
}

里式替换原则

  • 原则：引用基类的地方必须能透明的使用其子类的对象，使用继承时在子类中尽量不要重写父类的方法，通常的做法是，原来的父类和子类都去继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合的关系替代
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
"未使用里式替换原则"
public class Liskov {
	public static void main(String[] args) {
		A a = new A();
		System.out.println("11-3=" + a.func1(11, 3));
		System.out.println("1-8=" + a.func1(1, 8));

		B b = new B();
		System.out.println("11-3=" + b.func1(11, 3));"这里本意是求出11-3"
		System.out.println("11+3+9=" + b.func2(11, 3));
	}
}

"A类"
class A {
	"返回两个数的差"
	public int func1(int num1, int num2) {
		return num1 - num2;
	}
}

" B类继承了A"
" 增加了一个新功能：完成两个数相加,然后和9求和"
class B extends A {
	" 这里，重写了A类的方法, 可能是无意识"
	public int func1(int a, int b) {
		return a + b;
	}

	public int func2(int a, int b) {
		return func1(a, b) + 9;
	}
}
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
"使用里式替换原则"
public class Liskov {
	public static void main(String[] args) {
		B b = new B();
		"因为B类不再继承A类，因此调用者，不会再func1是求减法"
		"调用完成的功能就会很明确"
		System.out.println("11+3=" + b.func1(11, 3));"这里本意是求出11+3"
		System.out.println("11+3+9=" + b.func2(11, 3));
		
		
		"使用组合仍然可以使用到A类相关方法"
		System.out.println("11-3=" + b.func3(11, 3));"这里本意是求出11-3"
	}
}

"创建一个更加基础的基类"
class Base {
	"把更加基础的方法和成员写到Base类"
}

"A类"
class A extends Base {
	"返回两个数的差"
	public int func1(int num1, int num2) {
		return num1 - num2;
	}
}

"B类继承了A"
"增加了一个新功能：完成两个数相加,然后和9求和"
class B extends Base {
	"如果B需要使用A类的方法,使用组合关系"
	private A a = new A();
	
	"这里，重写了A类的方法, 可能是无意识"
	public int func1(int a, int b) {
		return a + b;
	}

	public int func2(int a, int b) {
		return func1(a, b) + 9;
	}
	
	"我们仍然想使用A的方法"
	public int func3(int a, int b) {
		return this.a.func1(a, b);
	}
}

开闭原则

  1. 是编程中最基础，最重要的设计原则
  2. 一个软件实体如类，模块或函数应该对扩展开放(对提供方)，对修改关闭(对使用方)，用抽象构建框架，用实现扩展细节
  3. 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码实现变化
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
"未使用开闭原则"
"这是一个用于绘图的类 [使用方]"
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;
	}
}
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
"使用开闭原则"
"这是一个用于绘图的类 [使用方]"
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(" 绘制其它图形 ");
	}
}

迪米特法则

  1. 一个对象应该对其他对象保持最小的了解
  2. 迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好，就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外除了提供的public方法，不对外泄露任何信息
  3. 迪米特法则更简单的定义是：只与直接的朋友通信
    • 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，就说这个两个对象之间是朋友关系。耦合的方式有很多，依赖，关联，组合，聚合。耦合中出现的成员变量，方法参数，方法的返回值中的类为直接朋友，出现在局部变量中的类不是直接朋友。陌生的类中最好不要以局部变量的形式出现在类的内部
  • 注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类之间的耦合，并不是要求完全没有依赖关系
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
"为使用迪米特法则"
public class Demeter1 {
	public static void main(String[] args) {
		"创建了一个 SchoolManager 对象"
		SchoolManager schoolManager = new SchoolManager();
		"输出学院的员工id 和  学校总部的员工信息"
		schoolManager.printAllEmployee(new CollegeManager());
	}
}

"学校总部员工类"
class Employee {
	private String id;

	public void setId(String id) {
		this.id = id;
	}
	public String getId() {
		return id;
	}
}

"学院的员工类"
class CollegeEmployee {
	private String id;

	public void setId(String id) {
		this.id = id;
	}
	public String getId() {
		return id;
	}
}

"管理学院员工的管理类"
class CollegeManager {
	"返回学院的所有员工"
	public List<CollegeEmployee> getAllEmployee() {
		List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
		for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
			CollegeEmployee emp = new CollegeEmployee();
			emp.setId("学院员工id= " + i);
			list.add(emp);
		}
		return list;
	}
}

"学校管理类"

"分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager"
"CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则"
class SchoolManager {
	"返回学校总部的员工"
	public List<Employee> getAllEmployee() {
		List<Employee> list = new ArrayList<Employee>();
		
		for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
			Employee emp = new Employee();
			emp.setId("学校总部员工id= " + i);
			list.add(emp);
		}
		return list;
	}

	"该方法完成输出学校总部和学院员工信息(id)"
	void printAllEmployee(CollegeManager sub) {
		
	    "分析问题"
	    "1. 这里的 CollegeEmployee 不是  SchoolManager的直接朋友"
	    "2. CollegeEmployee 是以局部变量方式出现在 SchoolManager"
	    "3. 违反了 迪米特法则 "

		"获取到学院员工"
		List<CollegeEmployee> list1 = sub.getAllEmployee();
		System.out.println("------------学院员工------------");
		for (CollegeEmployee e : list1) {
			System.out.println(e.getId());
		}
		"获取到学校总部员工"
		List<Employee> list2 = this.getAllEmployee();
		System.out.println("------------学校总部员工------------");
		for (Employee e : list2) {
			System.out.println(e.getId());
		}
	}
}
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
"使用迪米特法则"
"学校总部员工类"
class Employee {
	private String id;

	public void setId(String id) {
		this.id = id;
	}

	public String getId() {
		return id;
	}
}

"学院的员工类"
class CollegeEmployee {
	private String id;
	public void setId(String id) {
		this.id = id;
	}
	public String getId() {
		return id;
	}
}


"管理学院员工的管理类"
class CollegeManager {
	"返回学院的所有员工"
	public List<CollegeEmployee> getAllEmployee() {
		List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
		for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
			CollegeEmployee emp = new CollegeEmployee();
			emp.setId("学院员工id= " + i);
			list.add(emp);
		}
		return list;
	}
	
	"输出学院员工的信息"
	public void printEmployee() {
		"获取到学院员工"
		List<CollegeEmployee> list1 = getAllEmployee();
		System.out.println("------------学院员工------------");
		for (CollegeEmployee e : list1) {
			System.out.println(e.getId());
		}
	}
}

"学校管理类"

class SchoolManager {
	"返回学校总部的员工"
	public List<Employee> getAllEmployee() {
		List<Employee> list = new ArrayList<Employee>();
		
		for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
			Employee emp = new Employee();
			emp.setId("学校总部员工id= " + i);
			list.add(emp);
		}
		return list;
	}

	"该方法完成输出学校总部和学院员工信息(id)"
	void printAllEmployee(CollegeManager sub) {
		"分析问题"
		"1. 将输出学院的员工方法，封装到CollegeManager"
		sub.printEmployee();

		"获取到学校总部员工"
		List<Employee> list2 = this.getAllEmployee();
		System.out.println("------------学校总部员工------------");
		for (Employee e : list2) {
			System.out.println(e.getId());
		}
	}
}

合成复用原则

  • 原则：尽量使用合成/聚合方式，而不是使用继承

设计模式核心思想

  1. 找出应用中可能需要变化之外，把他们独立出来，不要和那些不需要变化的代码混合一起
  2. 针对接口编程，而不是针对实现编程
  3. 为交互对象之间的松耦合度设计

相关文章

UML类图