设计模式七大原则

单一职责原则

(Single Responsibility Principle)
对类来说的,即一个类应该只负责一项职责。

问题演示

、存在问题,职责不单一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SingleResponsibility1 {

public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run("摩托车");
vehicle.run("汽车");
vehicle.run("飞机");
}

}

// 交通工具类
// 方式1
// 1. 在方式1 的run方法中,违反了单一职责原则
// 2. 解决的方案非常的简单,根据交通工具运行方法不同,分解成不同类即可
class Vehicle {
public void run(String vehicle) {
System.out.println(vehicle + " 在公路上运行....");
}
}

解决方法

1)、类的职责单一

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
public class SingleResponsibility2 {

public static void main(String[] args) {
// TODO Auto-generated method stub
RoadVehicle roadVehicle = new RoadVehicle();
roadVehicle.run("摩托车");
roadVehicle.run("汽车");

AirVehicle airVehicle = new AirVehicle();

airVehicle.run("飞机");
}

}

//方案2的分析
//1. 遵守单一职责原则
//2. 但是这样做的改动很大,即将类分解,同时修改客户端
//3. 改进:直接修改Vehicle 类,改动的代码会比较少=>方案3

class RoadVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "公路运行");
}
}

class AirVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "天空运行");
}
}

class WaterVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "水中运行");
}
}

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

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
public class SingleResponsibility3 {

public static void main(String[] args) {
Vehicle2 vehicle2 = new Vehicle2();
vehicle2.run("汽车");
vehicle2.runWater("轮船");
vehicle2.runAir("飞机");
}

}


//方式3的分析
//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 + " 在水中行....");
}

//方法2.
//..
//..

//...
}

注意事项

1)、降低类的复杂度,一个类只负责一项职责。
2)、提高类的可读性,可维护性
3)、降低变更引起的风险
4)、通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则;
只有类中方法数量足够少,可以在方法级别保持单一职责原则

接口隔离原则

(Interface Segregation Principle)
客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上。

问题演示

对不需要的方法也进行了实现

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
public class Segregation1 {

public static void main(String[] args) {
// TODO Auto-generated method stub

}

}

//接口
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
public class Segregation1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
// 使用一把
A a = new A();
a.depend1(new B()); // A类通过接口去依赖B类
a.depend2(new B());
a.depend3(new B());

C c = new C();
c.depend1(new D()); // C类通过接口去依赖(使用)D类
c.depend4(new D());
c.depend5(new D());

//输出结果
// B 实现了 operation1
// B 实现了 operation2
// B 实现了 operation3
// D 实现了 operation1
// D 实现了 operation4
// D 实现了 operation5
}

}

// 接口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();
}
}

依赖倒转原则

(Dependence Inversion Principle)
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
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分析
//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
37
38
public class DependecyInversion {

public static void main(String[] args) {
//客户端无需改变
Person person = new Person();
person.receive(new Email());
person.receive(new WeiXin());
}

}

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

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

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

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

三种依赖传递

1)、普通方法参数传递

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 DependencyPass {

public static void main(String[] args) {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.open(changHong);
}

}

// 方式1: 通过接口传递实现依赖
// 开关的接口
interface IOpenAndClose {
void open(ITV tv); //抽象方法,接收接口
}

interface ITV { //ITV接口
void play();
}

class ChangHong implements ITV {

@Override
public void play() {
System.out.println("长虹电视机,打开");
}

}

// 实现接口
class OpenAndClose implements IOpenAndClose {
@Override
public void open(ITV tv) {
tv.play();
}
}

2)、构造方法参数传递

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
public class DependencyPass {

public static void main(String[] args) {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndClose(changHong);
openAndClose.open();
}

}

// 方式2: 通过构造方法依赖传递
interface IOpenAndClose {
void open(); //抽象方法
}

interface ITV { //ITV接口
void play();
}

class ChangHong implements ITV {
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}

class OpenAndClose implements IOpenAndClose {
public ITV tv; //成员

public OpenAndClose(ITV tv) { //构造器
this.tv = tv;
}

public void open() {
this.tv.play();
}
}

3)、setter方法参数传递

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
public class DependencyPass {

public static void main(String[] args) {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.setTv(changHong);
openAndClose.open();
}

}



// 方式3 , 通过setter方法传递
interface IOpenAndClose {
void open(); // 抽象方法
void setTv(ITV tv);
}

interface ITV { // ITV接口
void play();
}

class OpenAndClose implements IOpenAndClose {
private ITV tv;

@Override
public void setTv(ITV tv) {
this.tv = tv;
}

@Override
public void open() {
this.tv.play();
}
}

class ChangHong implements ITV {
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}

注意事项

1)、低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好.
2)、变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化
3)、继承时遵循里氏替换原则

里氏替换原则

(Liskov Substitution Principle)
1)、子类出现的地方可以被子类替换,在替换后依然保持原功能。
2)、在使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类的方法
3)、里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下,可以通过聚合,组合,依赖 来解决问题。

问题演示

B中fun2调用了fun1,但是这个fun1重写了父类A中的fun1

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
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));

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

//输出结果
// 1-8=-7
// 11-3=8
// -----------------------
// 11-3=14
// 1-8=9
// 11+3+9=23
}

}

// 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;
}
}

解决方法

把A和B都继承基类Base,此时A和B中都有fun1,但是不存在重写的关系了。
此时B中的fun2中调用了fun1,就与A无关系了,从而降低了耦合。

如果B中的fun3实在想使用A中的fun1方法,可以在B中创建成员变量A a,在fun3中使用a.fun1来调用A中的fun1方法

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
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));

System.out.println("-----------------------");
B b = new B();
//因为B类不再继承A类,因此调用者,不会再func1是求减法
//调用完成的功能就会很明确
System.out.println("11+3=" + b.func1(11, 3));//这里本意是求出11+3
System.out.println("1+8=" + b.func1(1, 8));// 1+8
System.out.println("11+3+9=" + b.func2(11, 3));

//使用组合仍然可以使用到A类相关方法
System.out.println("11-3=" + b.func3(11, 3));// 这里本意是求出11-3

//输出结果
// 11-3=8
// 1-8=-7
// -----------------------
// 11+3=14
// 1+8=9
// 11+3+9=23
// 11-3=8
}

}

//创建一个更加基础的基类
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);
}
}

开闭原则

(Open Close Principle)
是编程中最基础、最重要的设计原则。所有原则都是根据这个来设计的。

对扩展开放,对修改关闭。即:增加新功能,不改变原有代码。

问题演示

如果想新增三角形,1.增加类Triangle,2.增加方法drawTriangle,3.增加判断s.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
57
58
59
60
61
62
63
64
65
66
67
68
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 类做成抽象类,并提供一个抽象的 draw 方法,让子类去实现即可,
这样我们有新的图形种类时,只需要让新的图形类继承 Shape,并实现 draw 方法即可

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
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(" 绘制其它图形 ");
}
}

迪米特法则

(Law Of Demeter)
类与类交互时,在满足功能要求的基础上,传递的数据量越少越好。因为这样可能降低耦合度。

1)、一个对象应该对其他对象保持最少的了解
2)、类与类关系越密切,耦合度越大
3)、迪米特法则(Demeter Principle)又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部。对外除了提供的 public 方法,不对外泄露任何信息
4)、迪米特法则还有个更简单的定义:只与直接的朋友通信
5)、直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。
耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量方法参数方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部。

问题演示

在SchoolManager类中printAllEmployee方法中使用了局部变量List<CollegeEmployee> list1,而CollegeEmployee不是SchoolManager的直接朋友。

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
88
89
90
91
92
93
94
95
96
97
import java.util.ArrayList;
import java.util.List;

//客户端
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<>();
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<>();

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());
}
}
}

解决方法

把打印CollegeEmployee的打印,作为一个方法封装到CollegeManager类中。

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import java.util.ArrayList;
import java.util.List;

//客户端
public class Demeter1 {

public static void main(String[] args) {
System.out.println("~~~使用迪米特法则的改进~~~");
//创建了一个 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<>();
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());
}
}
}

//学校管理类

//分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类,这样违背了 迪米特法则
class SchoolManager {
//返回学校总部的员工
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<>();

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)、但是注意:由于每个类都减少了不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系, 并不是要求完全没有依赖关系

合成复用原则

(Composite Reuse Principle)
尽量使用合成/聚合达到复用,尽量少用继承。原则: 一个类中有另一个类的对象。

在这里插入图片描述

七大原则总结

1)、找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
2)、针对接口编程,而不是针对实现编程。
3)、为了交互对象之间的松耦合设计而努力