# 3.3 单一原则
# 3.3.1 介绍
- 一个类,接口,方法只负责一项职责
- 降低类的复杂度,一个类只负责一项职责,就减少了代码量,提高可读性,提高代码质量,降低变更引起的风险
# 3.3.2 代码示例
- 定义一个Human对象
public interface Human {
void eat();
void sleep();
}
1
2
3
4
2
3
4
- 定义一个认为程序员对象实现人类的方法
public abstract class Progarmer implements Human {
public abstract void work();
}
1
2
3
4
5
2
3
4
5
- 定义一个认为java程序员对象实现程序员的方法
public class JavaProgarmer extends Progarmer {
@Override
public void work() {
System.out.println("java programmer work...");
}
@Override
public void eat() {
System.out.println("java programmer eat...");
}
@Override
public void sleep() {
System.out.println("java programmer sleep...");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- 定义测试类
public class Test {
public static void main(String[] args) {
JavaProgarmer javaProgarmer = new JavaProgarmer(new Order());
javaProgarmer.work();
javaProgarmer.eat();
javaProgarmer.sleep();
}
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
- 此时如果希望程序员订外卖,如果如下的方式实现程序员订外卖方法,那么违反了单一职责原则,增加了程序复杂度,降低了可维护性
public class JavaProgarmer extends Progarmer {
@Override
public void work() {
System.out.println("java programmer work...");
}
@Override
public void eat() {
System.out.println("java programmer eat...");
}
@Override
public void sleep() {
System.out.println("java programmer sleep...");
}
/**
* 此时违背单一职责原则,所有人都可以订外卖,违背了程序员自己的职责
*/
//public void orderTake(){
// System.out.println("订外卖....");
//}
}
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
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
- 需要定义一个专门的订单对象,使java程序员实现订单对象中的订外卖操作
public class Order {
public void create(){
System.out.println("订外卖");
}
}
1
2
3
4
5
6
2
3
4
5
6
public class JavaProgarmer extends Progarmer {
private Order order;
public JavaProgarmer(Order order) {
this.order = order;
}
@Override
public void work() {
System.out.println("java programmer work...");
}
@Override
public void eat() {
System.out.println("java programmer eat...");
}
@Override
public void sleep() {
System.out.println("java programmer sleep...");
}
/**
* 此时违背单一职责原则,所有人都可以订外卖,违背了程序员自己的职责
*/
//public void orderTake(){
// System.out.println("订外卖....");
//}
/**
* 这样写程序员不违背自己的职责
*/
public void orderTake(){
order.create();
}
}
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
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
- 测试
public class Test {
public static void main(String[] args) {
JavaProgarmer javaProgarmer = new JavaProgarmer(new Order());
javaProgarmer.work();
javaProgarmer.eat();
javaProgarmer.sleep();
//订外卖
javaProgarmer.orderTake();
}
}
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
← 3.2 依赖倒转原则 3.4 接口隔离原则 →
