Android中所涉及的常用设计模式.docx

1、Android中所涉及的常用设计模式Android中所涉及的常用设计模式1、单例模式概念：Ensure a class has only one instance, and provide a global point of access to it.动态确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。优点： 1.1、由于单例模式在内存中只有一个实例，减少了内存开销。对于那些耗内存的类，只实例化一次，大大提高性能，尤其是移动开发中。1.2、单例模式可以避免对资源的多重占用，例如一个写文件时，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。1.3、单例模式可以在系

2、统设置全局的访问点，优化和共享资源访问。java view plain copy 在CODE上查看代码片派生到我的代码片public class Singleton private volatile static Singleton instance = null; private Singleton() public static Singleton getInstance() if (instance = null) synchronized (Singleton.class) if (instance = null) instance = new Singleton(); return

3、instance; 构造函数私有化，定义静态函数获得实例就不多说了，这里着重说一下volatile:volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从内存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.(首先我们要先意识到有这样的现象,编译器为了加快程序运行的速度,对一些变量的写操作会先在寄存器或者是CPU缓存上进行,最后才写入内存.而在这个过程,变量的新值对其他线程是不可见的.而volatile的作用就是使它修饰的变量的读写操作都必须在内存中进行!)synchronized 同步块大家都比较熟悉，通过 synchroni

4、zed 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用synchronized 修饰的方法 或者 代码块。volatile用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。再就是这个双重判断null :这是因为如果线程A进入了该代码，线程B 在等待，这是A线程创建完一个实例出来后，线程B 获得锁进入同步代码，实例已经存在，木有必要再创建一个，所以双重判断有必要。Android中 用到的地方很多，比如Android-Universal-Image-Lo

5、ader中的单例，EventBus中的单例最后给出一个管理我们activity的类，可以作为一个简单工具类java view plain copy 在CODE上查看代码片派生到我的代码片public class ActivityManager private static volatile ActivityManager instance; private Stack mActivityStack = new Stack(); private ActivityManager() public static ActivityManager getInstance() if (instance =

6、 null) synchronized (ActivityManager.class) if (instance = null) instance = new ActivityManager(); return instance; public void addActicity(Activity act) mActivityStack.push(act); public void removeActivity(Activity act) mActivityStack.remove(act); public void killMyProcess() int nCount = mActivityS

7、tack.size(); for (int i = nCount - 1; i = 0; i-) Activity activity = mActivityStack.get(i); activity.finish(); mActivityStack.clear(); android.os.Process.killProcess(android.os.Process.myPid(); 单例模式在Android源码中的应用： 在Android源码中，使用到单例模式的例子很多，如：InputMethodManager类html view plain copy 在CODE上查看代码片派生到我的代码片

8、public final class InputMethodManager static final boolean DEBUG = false; static final String TAG = InputMethodManager; static final Object mInstanceSync = new Object(); static InputMethodManager mInstance; final IInputMethodManager mService; final Looper mMainLooper; 创建唯一的实例static InputMethodManage

9、r mInstance;html view plain copy 在CODE上查看代码片派生到我的代码片/* * Retrieve the global InputMethodManager instance, creating it if it * doesnt already exist. * hide */ static public InputMethodManager getInstance(Context context) return getInstance(context.getMainLooper(); /* * Internally, the input method ma

10、nager cant be context-dependent, so * we have this here for the places that need it. * hide */ static public InputMethodManager getInstance(Looper mainLooper) synchronized (mInstanceSync) if (mInstance != null) return mInstance; IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE); II

11、nputMethodManager service = IInputMethodManager.Stub.asInterface(b); mInstance = new InputMethodManager(service, mainLooper); return mInstance; 防止多线程同时创建实例：synchronized (mInstanceSync) if (mInstance != null) return mInstance; 当没有创建实例对象时，调用mInstance = new InputMethodManager(service, mainLooper); 其中类构

12、造函数如下所示：html view plain copy 在CODE上查看代码片派生到我的代码片InputMethodManager(IInputMethodManager service, Looper looper) mService = service; mMainLooper = looper; mH = new H(looper); mIInputContext = new ControlledInputConnectionWrapper(looper, mDummyInputConnection); if (mInstance = null) mInstance = this; 2

13、、建造者模式（Builder 模式） 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示 概念就是比较抽象的，让大家很难理解的，如果简单从这个一个概念就搞懂了这个模式的话，那就不用费力的去查资料整理后边的东西了。 这里我们通过一个例子来引出Build模式。假设有一个Person类，他的一些属性可以为null,可以通过这个类来构架一大批人java view plain copy 在CODE上查看代码片派生到我的代码片public class Person private String name; private int age; private double heig

14、ht; private double weight; public String getName() return name; public void setName(String name) this.name = name; public int getAge() return age; public void setAge(int age) this.age = age; public double getHeight() return height; public void setHeight(double height) this.height = height; public do

15、uble getWeight() return weight; public void setWeight(double weight) this.weight = weight; 然后为了方便，你可能会写这么一个构造函数来传属性java view plain copy 在CODE上查看代码片派生到我的代码片public Person(String name, int age, double height, double weight) this.name = name; this.age = age; this.height = height; this.weight = weight; 或

16、者为了更方便还会写一个空的构造函数java view plain copy 在CODE上查看代码片派生到我的代码片public Person() 有时候还会比较懒，只传入某些参数，又会来写这些构造函数html view plain copy 在CODE上查看代码片派生到我的代码片public Person(String name) this.name = name; public Person(String name, int age) this.name = name; this.age = age; public Person(String name, int age, double he

17、ight) this.name = name; this.age = age; this.height = height; 于是就可以来创建各种需要的类html view plain copy 在CODE上查看代码片派生到我的代码片Person p1=new Person(); Person p2=new Person(张三); Person p3=new Person(李四,18); Person p4=new Person(王二,21,180); Person p5=new Person(麻子,16,170,65.4); 其实这种写法的坏处在你写的过程中想摔键盘的时候就该想到了，既然就是一

18、个创建对象的过程，怎么这么繁琐，并且构造函数参数过多，其他人创建对象的时候怎么知道各个参数代表什么意思呢，这个时候我们为了代码的可读性，就可以用一下Builder模式了 给Person类添加一个静态Builder类，然后修改Person的构造函数，如下：java view plain copy 在CODE上查看代码片派生到我的代码片public class Person private String name; private int age; private double height; private double weight; privatePerson(Builder builder

19、) this.name=builder.name; this.age=builder.age; this.height=builder.height; this.weight=builder.weight; public String getName() return name; public void setName(String name) this.name = name; public int getAge() return age; public void setAge(int age) this.age = age; public double getHeight() return

20、 height; public void setHeight(double height) this.height = height; public double getWeight() return weight; public void setWeight(double weight) this.weight = weight; static class Builder private String name; private int age; private double height; private double weight; public Builder name(String

21、name) this.name=name; return this; public Builder age(int age) this.age=age; return this; public Builder height(double height) this.height=height; return this; public Builder weight(double weight) this.weight=weight; return this; public Person build() return new Person(this); 从上边代码我们可以看到我们在Builder类中

22、定义了一份跟Person类一样的属性，通过一系列的成员函数进行赋值，但是返回的都是this,最后提供了一个build函数来创建person对象，对应的在Person的构造函数中，传入了Builder对象，然后依次对自己的成员变量进行赋值。此外，Builder的成员函数返回的都是this的另一个作用就是让他支持链式调用，使代码可读性大大增强 于是我们就可以这样创建Person对象java view plain copy 在CODE上查看代码片派生到我的代码片Person.Builder builder=new Person.Builder(); Person person=builder .na

23、me(张三) .age(18) .height(178.5) .weight(67.4) .build(); 是不是有那么点感觉了呢Android中大量地方运用到了Builder模式，比如常见的对话框创建java view plain copy 在CODE上查看代码片派生到我的代码片AlertDialog.Builder builder=new AlertDialog.Builder(this); AlertDialog dialog=builder.setTitle(对话框) .setIcon(android.R.drawable.ic_dialog) .setView(R.layout.c

24、ustom_view) .setPositiveButton(R.string.positive, new DialogInterface.OnClickListener() Override public void onClick(DialogInterface dialog, int which) ) .setNegativeButton(R.string.negative, new DialogInterface.OnClickListener() Override public void onClick(DialogInterface dialog, int which) ) .cre

25、ate(); dialog.show(); 其实在java中StringBuilder 和StringBuffer都用到了Builder模式，只不过是稍微简单一点了Gson中的GsonBuilderjava view plain copy 在CODE上查看代码片派生到我的代码片GsonBuilder builder=new GsonBuilder(); Gson gson=builder.setPrettyPrinting() .disableHtmlEscaping() .generateNonExecutableJson() .serializeNulls() .create(); 网络框

26、架OKHttphtml view plain copy 在CODE上查看代码片派生到我的代码片Request.Builder builder=new Request.Builder(); Request request=builder.addHeader(,) .url() .post(body) .build(); 可见大量框架运用了Builder 设计模式，总结一下吧：定义一个静态内部类Builder，内部成员变量跟外部一样Builder通过一系列方法给成员变量赋值，并返回当前对象（this）Builder类内部提供一个build方法方法或者create方法用于创建对应的外部类，该方法内部

27、调用了外部类的一个私有化构造方法，该构造方法的参数就是内部类Builder外部类提供一个私有化的构造方法供内部类调用，在该构造函数中完成成员变量的赋值3、 观察者模式定义:Define a one-to-many dependency between objects so that when one object changes state, all its dependents aer notified and updated automatically.定义对象间一种一对多的依赖关系，使得当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。主要包括四个部分：1. Subjec

28、t被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。这个好像还好理解那么一点点，不过还是先来讲个情景，天气预报的短信服务，一旦付费订阅，每次天气更新都会向你及时发送其实就是我们无需每时每刻关注我们感兴趣

29、的东西，我们只需要订阅它即可，一旦我们订阅的事务有变化了，被订阅的事务就会即时的通知我们我们来看一下观察者模式的组成：观察者，我们称它为Observer，有时候我们也称它为订阅者，即Subscriber被观察者，我们称它为Observable，即可以被观察的东西，有时候还会称之为主题，即Subject至于观察者模式的具体实现，java里为我们提供了Observable类和Observer接口供我们快速实现该模式，但是这里为了加深印象，不用这个两个类我们来模拟上边的场景，先定义一个Weather的类java view plain copy 在CODE上查看代码片派生到我的代码片public class Weather private String