Android常用设计模式（二）

Android常用设计模式之观察者模式

观察者设计模式在Android应用中会经常用到，模式原理类似于这样的场景：

用户订报纸，然后在报社登记，报社来统计用户（添加用户），用户也可以取消订阅，报社删除用户；然后用户观察报社，

当有了新的报纸，报社就告诉用户并发送报纸的用户的手上，这其中，用户是观察者，报社是被观察者，一旦报纸有了新的

（数据发生改变）报社就会通知用户；

代码示例如下：

首先我们根据用户的共同特征，都要接受报纸，来提取出来一个公共的用户接口

1 /**
2  * 用户接口
3  * 
4  * @author jiaocg
5  * 
6  */
7 public interface Users {
8     public void receive();//接受报纸方法
9 }

然后每一个用户都去实现这个接口，这里我们创建连个用户

用户A

 1 /**
 2  * 用户A
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class UserA implements Users {
 8 
 9     @Override
10     public void receive() {
11 
12         System.out.println("用户A收到了");
13 
14     }
15 
16 }

用户B

 1 /**
 2  * 用户B
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class UserB implements Users {
 8 
 9     @Override
10     public void receive() {
11 
12         System.out.println("用户B收到了");
13 
14     }
15 
16 }

然后我们创建被观察者报社类主要负责添加删除用户发报纸

 1 /**
 2  * 被观察者 报纸
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class NewSpaper {
 8     private List<Users> users = new ArrayList<Users>();
 9 
10     // 订报
11     public void addUser(Users user) {
12         users.add(user);
13 
14     }
15 
16     // 退订
17     public void removeUser(Users user) {
18         users.remove(user);
19     }
20 
21     // 发报
22     public void sendNewSpaper() {
23         for (Users user : users) {
24             user.receive();
25         }
26     }
27 
28 }

使用方式：

1 NewSpaper newSpaper = new NewSpaper();
2 newSpaper.addUser(new UserA());
3 newSpaper.addUser(new UserB());
4 
5 // 满足你的条件后 开始发报
6 newSpaper.sendNewSpaper();

代理模式

代理模式顾名思义就是自己不想做什么事情，让别人代表自己去做。比如我们要租房子，我们自己跑来跑去去找肯定很麻烦

我们可以直接去找中介，让中介去帮我们选合适的房子，中介找到合适的房子后再告诉我就可以了；

这里面就涉及到两个角色：代理者和被代理者，我是被代理者，中介是代理者；然后我和中介之间需要提取出来一个共同的抽象

类，我和中介都继承这个抽象类；这样任何使用我的地方，都可以使用中介来代替；中介内部含有对我的引用，从而可以在任何时候

对我进行操作；

在代理模式中的角色：

　　●　　抽象对象角色：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

　　●　　目标对象角色：定义了代理对象所代表的目标对象。

　　●　　代理对象角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，

以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

示例代码如下:

抽象对象角色

1 /**
2  * 代理和被代理对象 提取出来的抽象类
3  * @author jiaocg
4  *
5  */
6 public abstract class MyAndProxyObject {
7 
8     public abstract void doSomething();
9 }

目标对象角色

 1 /**
 2  * 被代理对象
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class MyObject extends MyAndProxyObject {
 8 
 9     @Override
10     public void doSomething() {
11 
12         System.out.println("我是本尊");
13 
14     }
15 
16 }

代理对象角色

 1 /**
 2  * 代理对象
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class ProxyObject extends MyAndProxyObject {
 8 
 9     MyObject myObject = new MyObject();
10 
11     @Override
12     public void doSomething() {
13 
14         beforeDoSomething();
15         myObject.doSomething();
16         afterDoSomething();
17 
18     }
19 
20     private void afterDoSomething() {
21 
22         System.out.println("代理之前的操作");
23 
24     }
25 
26     private void beforeDoSomething() {
27         System.out.println("代理之后的操作");
28 
29     }
30 
31 }

使用操作

1 ProxyObject proxyObject = new ProxyObject();
2 
3 proxyObject.doSomething();

直接实例化代理对象，我们队代理做的操作，实际上都会影响到目标对象；