装饰模式与职责链模式笔记

装饰模式（Decorator）

1. 概念
   动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
2. UML类图：
   
3. 代码
   给人打扮

//人类(ConcreteComponent)
public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("装扮的" + name);
    }

}
//服饰类（Decorator）
public class Finery extends Person{
    protected Person component;
    //打扮
    public void Decorate(Person component){
        this.component = component;
    }

    @Override
    public void show(){
        if (component != null){
            component.show();
        }
    }
}

//具体服装类(concreteDecorator)
class LeatherShoes extends Finery {
    @Override
    public void show() {
        System.out.print("皮鞋");
        super.show();
    }
}

//具体服装类(concreteDecorator)
class TShirts extends Finery{
    @Override
    public void show() {
        System.out.print("T恤");
        super.show();
    }
}

//具体服装类(concreteDecorator)
class Suit extends Finery{
    @Override
    public void show() {
        System.out.print("西装");
        super.show();
    }
}

//
class Demo{
    public static void main(String[] args) {
		Person person = new Person("查尔");
		
		LeatherShoes ls = new LeatherShoes();
        Suit suit = new Suit();
        TShirts ts = new TShirts();
        
		//装饰过程
		ls.Decorate(person);
        suit.Decorate(ls);
        ts.Decorate(suit);
        ts.show();
}
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

5. 总结：
   • 对原始功能的扩展（增强）。
   • 每个具体装饰类只关心自己的功能，不关心如何被添加到对象链当中。让户用在客户端根据需要有选择、按顺序地使用，实现不同效果。
   • 把类中的装饰功能从类中去除，简化原有的类，让其符合单一职责。
   • 有效地把类的核心职责和装饰功能分开，还可去除相关类中重复的装饰逻辑

职责链模式

1. 概念
   使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
2. UML类图：
   
3. 代码

//请求
public class Request {
    private String requestType;//申请类别
    private String requestContent;//内容
    private int number;//数量

    public String getRequestType() {
        return requestType;
    }
    
    public void setRequestType(String requestType) {
        this.requestType = requestType;
    }

    public String getRequestContent() {
        return requestContent;
    }

    public void setRequestContent(String requestContent) {
        this.requestContent = requestContent;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
}

//Handler类
abstract class Manager {
    protected String name;
    //管理者的上级
    protected Manager superior;

    public Manager(String name){
        this.name = name;
    }
    //设置管理者的上级
    public void setSuperior(Manager superior){
        this.superior=superior;
    }
    //申请请求
    abstract public void RequestApplications(Request request);
}

//ConcreteHandler类，经理
class CommonManager extends Manager {

    public CommonManager(String name) {
        super(name);
    }

    @Override
    public void RequestApplications(Request request) {
        if ("请假".equals(request.getRequestType()) && request.getNumber() <= 2) {
            System.out.println(name + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被比准");
        } else if (superior != null) {
            superior.RequestApplications(request);
        }
    }
}

/**
 * ConcreteHandler类，总监
 */
class Majordomo extends Manager {

    public Majordomo(String name) {
        super(name);
    }

    @Override
    public void RequestApplications(Request request) {
        if ( "请假".equals(request.getRequestType()) && request.getNumber() <= 5) {
            System.out.println(name + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被比准");
        } else if (superior != null) {
            superior.RequestApplications(request);
        }
    }
}

/**
 * ConcreteHandler类，总经理
 */
class GeneralManger extends Manager {

    public GeneralManger(String name) {
        super(name);
    }

    @Override
    public void RequestApplications(Request request) {
        if ( "请假".equals(request.getRequestType())) {
            System.out.println(name + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被比准");
        } else if ( "加薪".equals(request.getRequestType()) && request.getNumber() == 500) {
            System.out.println(name + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被比准");
        } else if ("加薪".equals(request.getRequestType()) && request.getNumber() > 500) {
            System.out.println(name + ":" + request.getRequestContent() + "数量" + request.getNumber() + "再说吧");
        }
    }
}


public class Demo {
    public static void main(String[] args) {
        CommonManager difan = new CommonManager("笛梵");
        Majordomo huashuo = new Majordomo("华硕");
        GeneralManger jinhuan = new GeneralManger("金换");
        //设置职责链的上家和下家
        difan.setSuperior(huashuo);
        huashuo.setSuperior(jinhuan);

        Request request = new Request();
        request.setRequestType("请假");
        request.setRequestContent("小白请假");
        request.setNumber(3);
        difan.RequestApplications(request);

        Request request1 = new Request();
        request1.setRequestType("加薪");
        request1.setRequestContent("小白请求加薪");
        request1.setNumber(500);
        difan.RequestApplications(request1);
    }
}
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

4. 总结：
   • 降低接受者与发送者耦合度； 一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，客户端只需要发起一次调用即可。
   • 核心思想就是分而治之。每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，把它们组织起来，形成一个链式的结构。
   • 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
   • 使用职责链要保证每个请求一定被处理。如果一个请求一直传到链的末端都得不到处理，这就槽糕了。