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。