Factory，Proxy，Observer，Visitor…
Creational patterns
Factory Method
当client不知道要创建哪个具体类的实例，或者不想在client代码中指明要具体 创建的实例时，用工厂方法。
Abstract Factory
提供接口以创建一组相关/相互依赖的对象， 但不需要指明其具体类。
Structural patterns
Proxy
某个对象比较“敏感”/“私密”/“贵重”，不希望被client直接访问 到，故设置proxy，在二者之间建立防火墙
举个例子：
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
| public interface Image {
void display();
}
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName){
this.fileName = fileName;
loadFromDisk(fileName);
}
@Override
public void display() {…}
private void loadFromDisk(String fileName){…}
}
public class ProxyImage implements Image {
private Image realImage;
private String fileName;
public ProxyImage(String fileName){
this.fileName = fileName;
}
@Override
public void display() {
if(realImage == null){
realImage = new RealImage(fileName);
}
realImage.display();
}
}
client:
Image image = new ProxyImage(“pic.jpg");
image.display();
|
Proxy vs Adaptor
Adapter: structural pattern
目的：消除不兼容，目的是client B以客户端期望的统一的方式与class A建立起联系。
Proxy: behavioral pattern
目的：隔离对复杂/重要对象的访问，降低难度/代价，定位在“访问/使用行为”
Behavioral patterns
Observer
定义：
指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。
形象点说：
“粉丝”对“偶像”感兴趣，希望随时得知偶像的一举一动。粉丝到偶像那里注册，偶像一旦有新闻发生，就推送给已注册的粉丝
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
| public class ObserverPattern
{
public static void main(String[] args)
{
Subject subject=new ConcreteSubject();
Observer obs1=new ConcreteObserver1();
Observer obs2=new ConcreteObserver2();
subject.add(obs1);
subject.add(obs2);
subject.notifyObserver();
}
}
abstract class Subject
{
protected List<Observer> observers=new ArrayList<Observer>();
public void add(Observer observer)
{
observers.add(observer);
}
public abstract void notifyObserver();
}
class ConcreteSubject extends Subject
{
public void notifyObserver()
{
System.out.println("具体目标发生改变...");
System.out.println("--------------");
for(Object obs:observers)
{
((Observer)obs).response();
}
}
}
public abstract class Observer
{
public Observer(Subject subject){
this.subject = subject;
this.subject.add(this);
}
public abstract void response();
}
class ConcreteObserver1 implements Observer
{
public void response()
{
System.out.println("具体观察者1作出反应！");
}
}
class ConcreteObserver2 implements Observer
{
public void response()
{
System.out.println("具体观察者2作出反应！");
}
}
|
优缺点：
优点如下：
- 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
- 目标与观察者之间建立了一套触发机制。
缺点如下：
- 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
- 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
Visitor
对特定类型的object的特定操作(visit)，在运行时将 二者动态绑定到一起，该操作可以灵活更改，无需更改被visit的类
本质上：将数据和作用于数据上的某种/些特定操作分离开来
