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。