家庭影院操作问题

组建一个家庭影院含有以下设备：DVD、投影仪、自动屏幕、音响、爆米花机、灯光，要求完成家庭影院的所有功能，过程为：

1. 开爆米花机
2. 放下屏幕
3. 开投影仪
4. 开音响
5. 开DVD
6. 取爆米花
7. 调暗灯光
8. 播放
9. 结束后关闭各个设备

传统方式解决影院问题

在调用端创建各个设备的对象，然后组织在一起完成整个过程

问题分析

1. 在caller处创建各个子系统的对象，并直接调用子系统相关方法，会造成调用过程混乱
2. 不利于维护对子系统的操作
3. 解决思路：定义一个高层接口，给子系统中的一组接口提供一个一致的界面，用来访问子系统中的一群接口，调用方不需要维护整个操作过程，只需要调用界面类提供的方法即可

外观模式

基本介绍

1. 外观模式也叫过程模式，外观模式为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用
2. 外观模式通过定义一个一致的接口，用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而不用关心这个子系统的内部细节

原理

1. 外观类：为caller提供统一的调用接口，外观类中聚合了各个子系统，它管理各个子系统，将子系统的功能组建在一起，提供给外部
2. 调用者：调用外观接口
3. 子系统集合：指模块或者子系统，处理外观类指派的任务，具体功能的提供者

外观模式解决影院问题

/***
 * @author shaofan
 * @Description 外观模式解决影院问题
 */
public class FamilyCinema {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.ready();
        facade.play();
        facade.pause();
        facade.end();
    }
}

class Facade{
    private DVDPlayer dvdPlayer;
    private Popcorn popcorn;
    private Projector projector;
    private Screen screen;
    private Stereo stereo;
    private Light light;
    public Facade(){
        this.dvdPlayer = DVDPlayer.getInstance();
        this.popcorn = Popcorn.getInstance();
        this.projector = Projector.getInstance();
        this.screen = Screen.getInstance();
        this.stereo = Stereo.getInstance();
        this.light = Light.getInstance();
    }

    /**
     * 准备工作
     */
    public void ready(){
        popcorn.on();
        popcorn.run();
        screen.down();
        projector.on();
        stereo.on();
        dvdPlayer.on();
        light.dim();
    }

    public void play(){
        dvdPlayer.run();
    }

    public void pause(){
        dvdPlayer.pause();
    }

    public void end(){
        light.light();
        popcorn.off();
        dvdPlayer.off();
        projector.off();
        screen.up();
        stereo.off();
    }

}
class DVDPlayer{
    private static final DVDPlayer INSTANCE = new DVDPlayer();
    public static DVDPlayer getInstance(){
        return INSTANCE;
    }
    public void on(){
        System.out.println("dvd on");
    }
    public void off(){
        System.out.println("dvd off");
    }

    public void run(){
        System.out.println("dvd is running");
    }
    public void pause(){
        System.out.println("dvd is pause");
    }
}

class Popcorn{
    private static final Popcorn INSTANCE = new Popcorn();
    public static Popcorn getInstance(){
        return INSTANCE;
    }
    public void on(){
        System.out.println("popcorn on");
    }
    public void off(){
        System.out.println("popcorn off");
    }
    public void run(){
        System.out.println("popcorn is running");
    }
}

class Projector{
    private static final Projector INSTANCE = new Projector();
    public static Projector getInstance(){
        return INSTANCE;
    }
    public void on(){
        System.out.println("projector on");
    }
    public void off(){
        System.out.println("projector off");
    }
    public void run(){
        System.out.println("projector is running");
    }
}

class Screen{
    private static final Screen INSTANCE = new Screen();
    public static Screen getInstance(){
        return INSTANCE;
    }
    public void up(){
        System.out.println("screen up");
    }
    public void down(){
        System.out.println("screen down");
    }
}

class Stereo{
    private static final Stereo INSTANCE = new Stereo();
    public static Stereo getInstance(){
        return INSTANCE;
    }
    public void on(){
        System.out.println("stereo on");
    }
    public void off(){
        System.out.println("stereo off");
    }
}

class Light{
    private static final Light INSTANCE = new Light();
    public static Light getInstance(){
        return INSTANCE;
    }
    public void on(){
        System.out.println("light on");
    }
    public void off(){
        System.out.println("light off");
    }
    public void dim(){
        System.out.println("light dim");
    }
    public void light(){
        System.out.println("light lighter");
    }
}
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

总结

1. 外观模式对外屏蔽了系统的细节，因此外观模式降低了客户端对子系统使用的复杂性
2. 外观模式降低了客户端与子系统的耦合关系，让子系统内部的模块更易维护和扩展
3. 通过合理的使用外观模式，可以更好的划分访问层次

应用场景

1. 系统需要分层设计时，可以考虑使用外观模式
2. 在维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时可以考虑为新系统开发一个外观类，来为遗留系统提供一套比较清晰的接口，让新系统的交互更加容易
3. 不能过多的或者不合理的使用外观模式，要让系统更有层次，利于维护