android之设计模式

这篇文章结合安卓来说一下常用的设计模式，主要只是解释一些设计模式的意义和android中对应的例子

单例模式

单例模式就是只生成一个实例，避免多个实例造成的浪费和冲突

在android里面对应的例子就是InputMethodManager

使用单例模式的时候，要主要多线程安全的问题，所以在生成函数上加锁

另外单例模式还分成饱汉模式和饿汉模式

饿汉模式的特点是在类初始化是就生成单例对象

private static final Singleton1 single = new Singleton1();  

否则就是饱汉模式

另外还有一种登记式的，其实就是使用一个HashMap来存储单例对象，这样我们就可以存储多个不同的单例了

01.import java.util.HashMap;  
02.import java.util.Map;  
03.//登记式单例类.   
04.//类似Spring里面的方法，将类名注册，下次从里面直接获取。   
05.public class Singleton3 {  
06.    private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();  
07.    static{  
08.        Singleton3 single = new Singleton3();  
09.        map.put(single.getClass().getName(), single);  
10.    }  
11.    //保护的默认构造子   
12.    protected Singleton3(){}  
13.    //静态工厂方法,返还此类惟一的实例   
14.    public static Singleton3 getInstance(String name) {  
15.        if(name == null) {  
16.            name = Singleton3.class.getName();  
17.            System.out.println("name == null"+"--->name="+name);  
18.        }  
19.        if(map.get(name) == null) {  
20.            try {  
21.                map.put(name, (Singleton3) Class.forName(name).newInstance());  
22.            } catch (InstantiationException e) {  
23.                e.printStackTrace();  
24.            } catch (IllegalAccessException e) {  
25.                e.printStackTrace();  
26.            } catch (ClassNotFoundException e) {  
27.                e.printStackTrace();  
28.            }  
29.        }  
30.        return map.get(name);  
31.    }  
32.    //一个示意性的商业方法   
33.    public String about() {      
34.        return "Hello, I am RegSingleton.";      
35.    }      
36.    public static void main(String[] args) {  
37.        Singleton3 single3 = Singleton3.getInstance(null);  
38.        System.out.println(single3.about());  
39.    }  
40.}  

 

策略模式

策略模式就是对于一件事，我们可以选择多种算法，当然这些算法在不同的类里面，而这些类又继承一个相同的接口，也就是面向接口编程

android里面一个具体例子就是adapter，这也可以看成一种策略模式，例如我们继承simapleAdapter，然后实现它的getview方法，不同的getview方法就是不同的策略

最后控件使用setAdapter（）方法选择不同的策略

 

工厂模式

工厂模式又称静态方法工厂模式，就是一个类（工厂），里面有一个方法可以生成大量的另外一个类（产品）

我们可以有很多很工厂，这样我们就可以生成不同的类，这些工厂要继承相同的接口，而产品也要继承相同的接口

好处是使抽象与实现分离, 客户程序不知道具体实现

android中的例子就是bitmapFactory

 

组合模式

组合模式就是多个类继承同一个接口，他们可以互相组合，从而产生新的类

例如程序设计书类可以提供所有的程序设计书籍名称，数据库书类可以提供所有的数据库书籍名称，那么假设要提供所有计算机类书籍的名称，我们就可以设计一个计算机书类，里面有前面两个类的方法组合成新的方法就可以了

android里面例子是view和viewgroup,viewgroup继承至view，所以也是view,同时它也可以包含其他的view，组合成新的布局

 

适配器模式

适配器模式最明显的例子就是adapter

其实适配器模式就是为了解决接口之间不兼容的问题而出现的

例如我们有一个类A，这个类很老，而且打包了，它提供一个方法get()来对外提供信息

而我们的新作业是收集各种信息，有一个收集类X，它有一个方法collect(class B),里面要传入B类型

其他信息可以通过继承B来实现，但是要提供A的信息怎么办呢，我们没有办法把A直接传入collect,也不知它的具体实现

这时我们可以创建一个C extends B,在C的get方法里面，调用A的get方法

01.public class ServerOne implements PlayerCount {  
02.      
03.    private ServerFirst mServerFirst;  
04.      
05.    public ServerOne() {  
06.        mServerFirst = new ServerFirst();  
07.    }  
08.  
09.    @Override  
10.    public String getServerName() {  
11.        return "一服";  
12.    }  
13.  
14.    @Override  
15.    public int getPlayerCount() {  
16.        return mServerFirst.getOnlinePlayerCount();  
17.    }  
18.  
19.}  

 

原型模式

原型模式简单来说就是复制，对于与java就是clone()方法

克隆操作分深拷贝和浅拷贝，浅拷贝说白了就是把原对象所有的值和引用直接赋给新对象。深拷贝则不仅把原对象的值赋给新对象，而且会把原对象的引用对象也重新创建一遍再赋给新对象。
android例子就是intent

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);      }  }  

 

观察者模式

观察者模式，有两个类，一个是观察者，一个是被观察者

被观察者有一个register来注册自己的观察者

注册完毕以后，被观察者就拥有了观察者的应用

但数据发送变化，也就是被观察者变化，那么我就可以调用被观察者的notify方法来通知观察者

实质就是在notify方法里面，调用观察者的onchange()方法

android里面的监听器就是观察者模式

当我们setAdapter(ListAdapter adapter)时，BaseAdapter同时注册了AdapterDataSetObserver()，至于AdapterDataSetObserver是如何通知Listvew和每个子item刷新（invalidate）的，这里涉及到的内容已经超出文章的范围，具体请查看源码。

模板方法模式

模板方法模式其实就是使用抽象类或者接口，来减少if语句的使用，使得代码更加可读

例如我们要解析xml和json两种格式，当然我们可以在if语句判断我们要有那种解析方式，但是这样整个结构就很长

我们为两种解析方式单独创建类，而且这两个类继承同一个抽象类，也就必须实现一个decode()方法,在这个方法里面我们再解析格式即可

android例子是view,和它的子类，子类一般重写了ondraw方法，从而显示不同的控件形象

public class View{        
    /**       * 钩子操作，空实现       */       
    protected void onDraw(Canvas canvas) {      }          

    /**       *钩子操作，空实现       */       
    protected void dispatchDraw(Canvas canvas) {      }           



    //算法骨架       
    public void draw(Canvas canvas) {           

    if (!verticalEdges && !horizontalEdges) {               

    // 步骤1              if (!dirtyOpaque) onDraw(canvas);                   

    // 步骤2              dispatchDraw(canvas);                   

    // 步骤3              onDrawScrollBars(canvas);                   

    return;          }        
    }        
    //... ...    
}    

 


public class TextView{        

    @Override     protected void onDraw(Canvas canvas) {   
    //大量自定义实现代码        
    }    
}