模式之常见设计模式

1.观察者模式   2.建造者模式

3.策略模式

4.适配器模式：

5.模板方法模式：

六.简单工厂模式 ,多个工厂方法模式，静态方法模式    七.原型模式  

--------

一.观察者模式：

观察者模式，是一种非常常见的设计模式，在很多系统中随处可见，尤其是涉及到数据状态发生变化需要通知的情况下。
本文以AbstractCursor为例子。
观察者模式，Observer Pattern, 是一个很实用的模式，参与项目中打印模板解释器中都用到了此模式。

总结：
(1).行为型模式
(2).目标和观察者间的抽象耦合(经典实现)。
(3).支持广播通信(相信这点android开发者看到后应该有启发吧)。
(4).注意意外的更新，这也是观察者更新进行管理的原因之一。

1.意图
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
热门词汇：依赖 发布-订阅 事件 通知 更新 监听 

2.结构 

这是一个最简单的观察者模式，目标对象能够添加和删除观察者，当自己某种状态 或者 行为发生改变时，可通过notify通知注册的观察者进行更新操作。
分析AbstractCursor的具体情况，我们发现实际工作有时需要对观察者进行统一管理，甚至观察者类型有很多种而又可以分成几个系列，这个时候是要复杂的多，通过合理的分层这个问题很好解决。下面根据具体情况，我们画出android中abstractCurosr中用到的观察者模式结构图：

观察者分成了两个系列。 

3.代码
列举其中相关核心代码如下： 

1. public abstract class AbstractCursor {  
2.     //定义管理器  
3.     DataSetObservable mDataSetObservable = new DataSetObservable();  
4.     ContentObservable mContentObservable = new ContentObservable();  
5.     //注册和卸载两类观察者  
6.     public void registerContentObserver(ContentObserver observer) {  
7.         mContentObservable.registerObserver(observer);  
8.     }  
9.     public void unregisterContentObserver(ContentObserver observer) {  
10.         // cursor will unregister all observers when it close  
11.         if (!mClosed) {  
12.             mContentObservable.unregisterObserver(observer);  
13.         }  
14.     }  
15.     public void registerDataSetObserver(DataSetObserver observer) {  
16.         mDataSetObservable.registerObserver(observer);     
17.     } 
18.     public void unregisterDataSetObserver(DataSetObserver observer) {  
19.         mDataSetObservable.unregisterObserver(observer);  
20.     }  
21.     //2类通知方法  
22.     protected void onChange(boolean selfChange) {  
23.         synchronized (mSelfObserverLock) {  
24.             mContentObservable.dispatchChange(selfChange);  
25.             if (mNotifyUri != null && selfChange) {  
26.                 mContentResolver.notifyChange(mNotifyUri, mSelfObserver);  
27.             }  
28.         }  
29.     }  
30.     protected void notifyDataSetChange() {  
31.         mDataSetObservable.notifyChanged();  
32.     }  
33. }  

再看看Observable<T>类和DataSetObservable类:

1. public abstract class Observable<T> {  
2.     /**  
3.      * 观察者列表  
4.      */ 
5.     protected final ArrayList<T> mObservers = new ArrayList<T>();  
6.     public void registerObserver(T observer) {  
7.         if (observer == null) {  
8.             throw new IllegalArgumentException("The observer is null.");  
9.         }  
10.         synchronized(mObservers) {  
11.             if (mObservers.contains(observer)) {  
12.                 throw new IllegalStateException("Observer " + observer + " is already registered.");  
13.             }  
14.             mObservers.add(observer);  
15.         }  
16.     }  
17.     public void unregisterObserver(T observer) {  
18.         if (observer == null) {  
19.             throw new IllegalArgumentException("The observer is null.");  
20.         }  
21.         synchronized(mObservers) {  
22.             int index = mObservers.indexOf(observer);  
23.             if (index == -1) {  
24.                 throw new IllegalStateException("Observer " + observer + " was not registered.");  
25.             }  
26.             mObservers.remove(index);  
27.         }  
28.     }  
29.     public void unregisterAll() {  
30.         synchronized(mObservers) {  
31.             mObservers.clear();  
32.         }          
33.     }  
34. }  和 

1. public class DataSetObservable extends Observable<DataSetObserver> {  
2.     /**  
3.      * 数据发生变化时，通知所有的观察者  
4.      */ 
5.     public void notifyChanged() {  
6.         synchronized(mObservers) {  
7.             for (DataSetObserver observer : mObservers) {  
8.                 observer.onChanged();  
9.             }  
10.         }  
11.     }  
12.     //... ... (其他方法)  
13. }  

观察者DataSetObserver类是一个抽象类：

1. public abstract class DataSetObserver {  
2.     public void onChanged() {  
3.         // Do nothing  
4.     }  
5. }  

所以我们具体看它的子类：

1. public class AlphabetIndexer extends DataSetObserver{  
2.     /*  
3.      * @hide 被android系统隐藏起来了  
4.      */ 
5.     @Override 
6.     public void onChanged() {  
7.         //观察到数据变化，观察者做自己该做的事情  
8.         super.onChanged();  
9.         mAlphaMap.clear();  
10.     }  
11. }   

ContentObserver也是类似。

二. 建造者模式：
定义： 将一个复杂对象构建与它的表示分离，使得同样的构建过程可以创建不同的表示。即将配置从目标类中隔离出来，避免过多的setter方法。
场景：AlertDialog内部类Builder构建参数过程、Notification使用Bulider(建造者)完成参数初始化。
形式：参数的链式调用；
优点:
• 良好的封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节。
• 建造者独立，容易扩展。
缺点:
• 会产生多余的 Builder 对象以及 Director 对象，消耗内存。

其实很多场景，Android并没有完全按照GOF的经典设计模式来实现，而是做了一些修改，使得这个模式更易于使用。在AlertDialog的Builder模式中并没有看到Direcotr角色出现，这个的AlertDialog.Builder同时扮演了上下文中提到的builder、ConcreteBuilder、Director 的角色，简化Builder模式的设计。
当模块比较稳定，不存在一些变化时，可以在经典模式实现的基础上做出一些精简，而不是照搬GOF上的经典实现，更不要生搬硬套，使程序失去架构之美。

三.策略模式

1、策略模式概念

定义一系列算法，把他们独立封装起来，并且这些算法之间可以相互替换。

策略模式主要是管理一堆有共性的算法，客户端可以根据需要，很快切换这些算法，并且保持可扩展性。

策略模式的本质：分离算法，选择实现。

2、策略模式实现

策略模式实现起来，主要需要3部分：抽象接口、实现算法、上下文。

1. //算法的接口 
2. public interface PriceStrategy 
3. { 
4.     public int setPrice(int orgPrice); 
5. } 

1. //实现一个接口，打7折商品 
2. public class sevenPercentStrategy implements PriceStrategy 
3. { 
4. public int setPrice(int orgPrice) 
5.     { 
6.           System.out.println("打7折商品"); 
7.           return orgPrice*0.7; 
8.     } 
9. } 
10. //实现一个接口，打5折商品 
11. public class fivePercentStrategy implements PriceStrategy 
12. { 
13. public int setPrice(int orgPrice) 
14.     { 
15.           System.out.println("打5折商品"); 
16.           return orgPrice*0.5; 
17.     } 
18. } 

1. //实现一个上下文对象 
2. public class DstPrice 
3. {   
4.     private PriceStrategy mPriceStrategy;   
5.     public void setPriceMode(PriceStrategy priceMode) 
6.     {   
7.         mPriceStrategy = priceMode;   
8.     }   
9.     public int ExeCalPrice(int price) 
10.     {   
11.         mPriceStrategy.SetPrice(price); 
12.     }   
13. }   

上面是一个最简单的策略模式的实现方式，按照功能分为3个部分，定义算法抽象接口，然后根据具体算法实现这些接口，最后需要定义一个上下文对象。

这里的上下文对象主要用来切换算法，上下文对象里面也是针对接口编程，具体算法实现被封装了。

3、策略模式的理解

上面实现的只是一种最简单的策略模式的框架，实际应用的时候，针对不同情况修改上下文对象和具体的算法实现。比如说，可以增加一个抽象类实现作为算法模板。抽象类里面我们可以封装一些公共的方法。这样实现具体的算法的时候，每个算法公共部分就被分离出来。

策略模式的目的是把具体的算法抽离出来，把每个算法独立出来。形成一系列有共同作用的算法组，然后这个算法组里面的算法可以根据实际情况进行相互替换。

策略模式的中心不是如何实现这些算法，而是如何组织和调用这些算法。也就是把我们平时写到一块的算法解耦出来，独立成一个模块，增强程序的扩展性。

策略模式里面的算法通常需要数据执行，我们可以根据实际情况把数据放在不同地方。例如可以放在上下文类里面，然后每个算法都可以使用这些数据。或者对接口封装一个抽象类，在抽象类里面添加数据。这些可以根据实际的情况综合考虑。设计模式里面没有一成不变的万能模式，每种模式都有变化版本，需要根据实际的项目进行变通。

4、策略模式优缺点

定义一系列算法：策略模式的功能就是定义一系列算法，实现让这些算法可以相互替换。所以会为这一系列算法定义公共的接口，以约束一系列算法要实现的功能。如果这一系列算法具有公共功能，可以把策略接口实现成为抽象类，把这些公共功能实现到父类里面，对于这个问题，前面讲了三种处理方法，这里就不罗嗦了。

避免多重条件语句：根据前面的示例会发现，策略模式的一系列策略算法是平等的，可以互换的，写在一起就是通过if-else结构来组织，如果此时具体的算法实现里面又有条件语句，就构成了多重条件语句，使用策略模式能避免这样的多重条件语句。

更好的扩展性：在策略模式中扩展新的策略实现非常容易，只要增加新的策略实现类，然后在选择使用策略的地方选择使用这个新的策略实现就好了。

客户必须了解每种策略的不同： 策略模式也有缺点，比如让客户端来选择具体使用哪一个策略，这就可能会让客户需要了解所有的策略，还要了解各种策略的功能和不同，这样才能做出正确的选择，而且这样也暴露了策略的具体实现。

增加了对象数目：由于策略模式把每个具体的策略实现都单独封装成为类，如果备选的策略很多的话，那么对象的数目就会很可观。

只适合扁平的算法结构：策略模式的一系列算法地位是平等的，是可以相互替换的，事实上构成了一个扁平的算法结构，也就是在一个策略接口下，有多个平等的策略算法，就相当于兄弟算法。而且在运行时刻只有一个算法被使用，这就限制了算法使用的层级，使用的时候不能嵌套使用。

5、Android中的应用

 在Android里面，策略模式的其中一个典型应用就是Adapter，在我们平时使用的时候，一般情况下我们可能继承BaseAdapter，然后实现不同的View返回，GetView里面实现不同的算法。   外部使用的时候也可以根据不同的数据源，切换不同的Adapter。

四.适配器模式：

安卓里面经常用到的控件Recycleview和ListView我们经常会写adapter,就是适配器的意思， ，这里晚上找到的随便给一个，例子来源于这篇文章

代码实现如下：
// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
class Adaptee {
    public void specificRequest() {
        System.out.println("被适配类具有 特殊功能...");
    }
}
// 目标接口，或称为标准接口
interface Target {
    public void request();
}
// 具体目标类，只提供普通功能
class ConcreteTarget implements Target {
    public void request() {
        System.out.println("普通类 具有 普通功能...");
    }
}
// 适配器类，继承了被适配类，同时实现标准接口
class Adapter extends Adaptee implements Target{
    public void request() {
        super.specificRequest();
    }
}
// 测试类
public class Client {
    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();
        concreteTarget.request();
        // 使用特殊功能类，即适配类
        Target adapter = new Adapter();
        adapter.request();
    }
}
测试结果：
普通类 具有 普通功能...
被适配类具有 特殊功能...

实质上就是衔接我们的目标类和具有适配操作的类，从而达到适配器效果，最常用的电源适配器进行理解，我们的笔记本需要12V电压进行工作，

但是需要目标类的Convert方法进行220V到12V的转换功能，但是220到12V的具体操作由另外一个具有转换功能的类来实现，我们可以通过适配器进行衔接。

安卓中的adapter，我们的BaseAdapter抽象了具体的流程，getCount（），getDatas（），getView（）等等一系列操作，但是我们的数据模型又是不一样的，可能是ListView<String>,List<CoustomBean>,等等，这里数据模型充当着具体的执行者，我们通过传入不同的数据模型来达到实现多种数据展示的效果。
最后通过recycleview的setAdapter（）方法来设置适配器达到效果。

六.简单工厂模式 Simple Factory

简单工厂模式的作用就是定义一个用于创建对象的接口

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化。

首先定义一个接口

public interface Sender{
    public void send();
}

创建类实现Sender接口

public class Qq implements Sender{
    @Override
    public void send() {
        // TODO Auto-generated method stu
        System.out.println("this is qq send!"); 
    }
}

public class Weixin implements Sender {
    @Override
    public void send() {
        // TODO Auto-generated method stub
        System.out.println("this is Weixin send!"); 
    }
}

创建一个工厂类

public class SenderFactory {
    public Sender sendproduce(String type)
    {
        if(type.equals("qq"))
        {
            return new Qq();
        }
        else if(type.equals("wx"))
        {
            return new Weixin();
        }
        else
        {
            return null;
        }
    }
}

具体用法

public class Test1 {
    public static void main(String[] args) {
        SenderFactory factory = new SenderFactory();
        Sender sender = factory.sendproduce("qq");
        sender.send();
    }
}

运行得到的结果

this is qq send!

6.2.设计模式之多个工厂方法模式，静态方法模式

接着上篇文章的简单工厂模式，做以下修改，即可实现多个工厂方法模式

public class SenderFactory {
//    public Sender sendproduce(String type)
//    {
//        if(type.equals("qq"))
//        {
//            return new Qq();
//        }
//        else if(type.equals("wx"))
//        {
//            return new Weixin();
//        }
//        else
//        {
//            return null;
//        }}
    public Sender qqsend(){
        return new Qq();
    }
    public static Sender weixinsend(){
        return new Weixin();
    }
}

具体调用,一个是采用静态方法调用

public class Test1 {
    public static void main(String[] args) {
        SenderFactory factory = new SenderFactory();
        Sender sender = factory.qqsend();
        sender.send();

    }
}

七.原型模式：

CV一族，应该很容易理解原型模式的原理，复制，粘贴完后看具体情况是否修改，其实这就是原型模式。
从java的角度看，一般使用原型模式有个明显的特点，就是实现cloneable的clone()方法。
原型模式，能快速克隆出一个与已经存在对象类似的另外一个我们想要的新对象。

1.意图
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
热门词汇：克隆 深拷贝 浅拷贝

2.结构图和代码
它的结构图非常简单，我们以Intent为例子：

Intent的clone方法非常简单：

1. @Override 
2. public Object clone() {  
3.     return new Intent(this);  
4. }  

返回一个新的Intent对象。
克隆操作分深拷贝和浅拷贝，浅拷贝说白了就是把原对象所有的值和引用直接赋给新对象。深拷贝则不仅把原对象的值赋给新对象，而且会把原对象的引用对象也重新创建一遍再赋给新对象。
我们具体分析一下Intent是浅拷贝还是深拷贝吧：

1. public Intent(Intent o) {  
2.     this.mAction = o.mAction;  
3.     this.mData = o.mData;  
4.     this.mType = o.mType;  
5.     this.mPackage = o.mPackage;  
6.     this.mComponent = o.mComponent;  
7.     this.mFlags = o.mFlags;  
8.     //下面几个是引用对象被重新创建了，是深拷贝  
9.     if (o.mCategories != null) {  
10.         this.mCategories = new HashSet<String>(o.mCategories);  
11.     }  
12.     if (o.mExtras != null) {  
13.         this.mExtras = new Bundle(o.mExtras);  
14.     }  
15.     if (o.mSourceBounds != null) {  
16.         this.mSourceBounds = new Rect(o.mSourceBounds);  
17.     }  
18. }  

这里我们为什么Intent要重写Object的clone方法，就与深拷贝有关。
其实我们查看Object的clone()方法源码和注释，默认的super.clone()用的就是浅拷贝：

1. protected Object clone() throws CloneNotSupportedException {  
2.     if (!(this instanceof Cloneable)) {  
3.         throw new CloneNotSupportedException("Class doesn't implement Cloneable");  
4.     }  
5.     return internalClone((Cloneable) this);  
6. }  

这种形式属于简单形式的原型模式，如果需要创建的原型数目不固定，可以创建一个原型管理器，在复制原型对象之前，客户端先在原型管理器中查看
是否存在满足条件的原型对象，如果有，则直接使用，如果没有，克隆一个，这种称作登记形式的原型模式。
适用原型模式可以对客户隐藏产品的具体类，因此减少了客户知道的名字的数目，此外是客户无需改变
原型模式的缺陷是每个原型的子类都必须实现Cloneable接口，这个实现起来有时候比较困难。

3.效果
(1).创建型模式
(2).运行时刻增加和删除产品
(3).改变只以指定新对象（ctrl+v，然后修改）
(4).改变结构以指定新对象。（类似2，实现不同而已）
(5).减少子类的构造