Android从零单排--常见设计模式

1.组合模式

将对象View和ViewGroup组合成树形结构以表示”部分-整体”的层次结构(View可以做为ViewGroup的一部分)。

public class View{ 
        //... ... 
} 

public abstract class ViewGroup extends View{ 
    /** Adds a child view.    */ 
   public void addView(View child) { 
       //... 
    }  
   public void removeView(View view) { 
       //... 
    } 
   /** Returns the view at the specified position in the group.*/ 
   public View getChildAt(int index) { 
      try { 
           return mChildren[index];  
      } catch (IndexOutOfBoundsException ex) { 
           return null; 
      } 
   } 
    //other methods 
} 

效果 : 能够灵活控制基本对象与组合对象的使用。

2.单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点
以输入法管理者InputMethodManager为例

public final class InputMethodManager {  
    static final Object mInstanceSync = new Object();//同步  
    //内部全局唯一实例  
    static InputMethodManager mInstance;  

    //对外api  
    static public InputMethodManager getInstance(Context context) {  
        return getInstance(context.getMainLooper());  
    }  

    /**  
     * 内部api，供上面的外部api调用  
     * @hide 系统隐藏的api  
     */ 
    static public InputMethodManager getInstance(Looper mainLooper) {  
        synchronized (mInstanceSync) {  
            if (mInstance != null) {  
                return mInstance;  
            }  
            IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);  
            IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);  
            mInstance = new InputMethodManager(service, mainLooper);  
        }  
        return mInstance;  
    }  
}  

调用

class ContextImpl extends Context{  
    @Override  
    public Object getSystemService(String name) {  
        if (WINDOW_SERVICE.equals(name)) {  
            //... ... 省略下面n个if，else if  
        } else if (INPUT_METHOD_SERVICE.equals(name)) {  
            //获取输入法管理者唯一实例  
            return InputMethodManager.getInstance(this);  
        }  else if (KEYGUARD_SERVICE.equals(name)) {  
             //... ... 省略下面n个if，else if  
        } else if (ACCESSIBILITY_SERVICE.equals(name)) {  
            //又见单例，无处不在  
            return AccessibilityManager.getInstance(this);  
        } else if (LOCATION_SERVICE.equals(name)) {  
            //... ... 省略下面n个if，else if  
        }  else if (NFC_SERVICE.equals(name)) {  
            return getNfcManager();  
        }  
        return null;  
    }  
}  

效果 : 对唯一实例的受控访问, 避免全局变量污染命名空间, 比类操作更灵活。

3.观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
观察者模式与回调模式有很多的相似处，简单对比就是：回调是一对一的关系，只监听一个事件；观察者模式则是一个主题，可以有多个监听，观察者模式是一对多的关系。

/* 被观察主题 */
public interface Subject {  
    public void addObserver(Observer observer);  
    public void removeObserver(Observer observer);  
    public void notifyObservers();  
}  

/* 观察者 */
public interface Observer {  
    public void update(String msg);  
}  

public class SubjectImp implements Subject{  

    private  List<Observer> list=new ArrayList<Observer>();  
    private String msg;  

    @Override  
    public void addObserver(Observer observer) {  
        // TODO Auto-generated method stub  
        list.add(observer);  
    }  

    @Override  
    public void removeObserver(Observer observer) {  
        // TODO Auto-generated method stub  
        int index=list.indexOf(observer);  
        if(index>=0){  
            list.remove(index);  
        }  
    }  

    @Override  
    public void notifyObservers() {  
        // TODO Auto-generated method stub  
        for(Observer observer:list){  
            observer.update(msg);  
        }  
    }  

    public void setMsg(String msg){  
        this.msg=msg;  
        notifyObservers();  
    }  

}  

public class ObserverImp implements Observer{  

    Subject subject;  
    public ObserverImp(Subject subject){  
        this.subject=subject;  
        subject.addObserver(this);  
    }  
    @Override  
    public void update(String msg) {  
        // TODO Auto-generated method stub  
        System.out.println("ObserverImp 收到："+msg);  
    }  

} 




public class ObserverImp1 implements Observer{  

    Subject subject;  
    public ObserverImp1(Subject subject){  
        this.subject=subject;  
        subject.addObserver(this);  
    }  
    @Override  
    public void update(String msg) {  
        // TODO Auto-generated method stub  
        System.out.println("ObserverImp1 收到："+msg);  
    }  

}  

调用

SubjectImp subjectImp=new SubjectImp(); 
ObserverImp observerImp=new ObserverImp(subjectImp);   
ObserverImp1 observerImp1=new ObserverImp1(subjectImp);  
subjectImp.setMsg("ok");
/* 结果会打印出两条 ObserverImp 收到：ok 和 ObserverImp1 收到：ok */

效果 : 目标和观察者间的抽象耦合,支持广播通信。

4. 策略模式

定义一系列算法，把他们独立封装起来，并且这些算法之间可以相互替换。
最常用也最常见的使用模式。
最简单的策略模式的实现方式，按照功能分为3个部分，定义算法抽象接口，然后根据具体算法实现这些接口，最后需要定义一个上下文对象。

以最常见的收银台打折、满减为例

//算法的接口 
public interface PriceStrategy 
{ 
    public int getPrice(int orgPrice); 
} 

//实现一个接口，打7折商品 
public class sevenPercentStrategy implements PriceStrategy 
{ 
public int getPrice(int orgPrice) 
    { 
          System.out.println("打7折商品"); 
          return orgPrice*0.7; 
    } 

} 
//实现一个接口，满500-100
public class fullMinusStrategy implements PriceStrategy 
{ 
public int getPrice(int orgPrice) 
    { 
          System.out.println("满500-100"); 
          return orgPrice>=500? orgPrice-100 : orgPrice; 
    } 

} 

//实现一个上下文对象 
public class DstPrice 
{   
    private PriceStrategy mPriceStrategy;   

    public void setPriceMode(PriceStrategy priceMode) 
    {   
        mPriceStrategy = priceMode;   
    }   

    public int ExeCalPrice(int price) 
    {   
        mPriceStrategy.getPrice(price); 
    }   
}   

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