Android常用的设计模式（二）

工厂方法模式

1.意图
定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方式模式使一个类的实例化延迟到其子类。也就是不采用硬编码new的方式生成对象，将构造过程封装到Factory的实现类中。方便的创建复杂的对象。最关键的是客户端创建产品是可以根据情况创建，灵活的高。
2.结构

3.线程结构及代码

//抽象产品  
public interface Runnable {  
    public abstract void run();  
}  

//抽象工厂  
public interface ThreadFactory {  
    Thread newThread(Runnable r);  
}  
//工厂实现类 
private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
    private final AtomicInteger mCount = new AtomicInteger(1);  

    public Thread newThread(Runnable r) {  
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
    }  
}; 

4.效果
(1).创建型模式;
(2).参数化工厂方法模式得到相应的对象;
(3).为子类提供挂钩;
(4).连接平行的类层次。

适配器模式

1.意图
适配器模式，把一个类的接口变换成客户端所期待的另一种接口，从而使原本不匹配而无法在一起工作的两个，类能够在一起工作。
适配器模式分为类适配器模式和对象适配器模式。
关于类适配器模式，因为java的单继承，如果继承一个类，另外的则只能是接口，需要手动实现相应的方法。
2.结构图

3.代码

我们以最简单的若干个方法举例如下，ListAdapter接口如下（，为了简单，我省略了继承自Adapter接口）：

public interface ListAdapter {  
    public int getCount();  
    Object getItem(int position);  
    long getItemId(int position);  
    View getView(int position, View convertView, ViewGroup parent);  
    boolean isEmpty();  
}  

抽象类BaseAdapter,我省略其他代码，只列出两个方法，以作示意:

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {  
    // ... ...  
    public View getDropDownView(int position, View convertView, ViewGroup parent) {  
        return getView(position, convertView, parent);  
    }  
    public boolean isEmpty() {  
        return getCount() == 0;  
    }  
}  

ArrayAdapter对List进行封装成ListAdapter的实现，满足ListView的调用：

public class ArrayAdapter<T> extends BaseAdapter implements Filterable {  
    private List<T> mObjects;  
    //我只列出这一个构造函数，大家懂这个意思就行  
    public ArrayAdapter(Context context, int textViewResourceId, T[] objects) {  
        init(context, textViewResourceId, 0, Arrays.asList(objects));  
    }  
    private void init(Context context, int resource, int textViewResourceId, List<T> objects) {  
        mContext = context;  
        mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
        mResource = mDropDownResource = resource;  
        mObjects = objects; //引用对象，也是表达了组合优于继承的意思  
        mFieldId = textViewResourceId;  
    }  
    public int getCount() {  
        return mObjects.size();  
    }  
   public T getItem(int position) {  
        return mObjects.get(position);  
    }  
    public View getView(int position, View convertView, ViewGroup parent) {  
        return createViewFromResource(position, convertView, parent, mResource);  
    }  
    // ... ...  
}  

4.效果
(1).结构性模式
(2).上面论述的主要是对象适配器，关于类适配器除了实现目标端口外，还要实现你要兼容的源类，这样可以少写几行代码，但是从组合优于继承的角度看，它总则没有那么的干净。
(3).对同一个适配器（即同一个对象）对同样的源进行双向甚至多向的适配，则能使其适用两个甚至多个客户调用。

原型模式

1.意图
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
浅拷贝：就是把原对象所有的值和引用直接赋给新对象。
深拷贝：不仅把原对象的值赋给新对象，而且会把原对象的引用对象也重新创建一遍再赋给新对象。
2.结构

3.代码

public Intent(Intent o) {  
    this.mAction = o.mAction;  
    this.mData = o.mData;  
    this.mType = o.mType;  
    this.mPackage = o.mPackage;  
    this.mComponent = o.mComponent;  
    this.mFlags = o.mFlags;  
    //下面几个是引用对象被重新创建了，是深拷贝  
    if (o.mCategories != null) {  
        this.mCategories = new HashSet<String>(o.mCategories);  
    }  
    if (o.mExtras != null) {  
        this.mExtras = new Bundle(o.mExtras);  
    }  
    if (o.mSourceBounds != null) {  
        this.mSourceBounds = new Rect(o.mSourceBounds);  
    }  
}  

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