Android常见的设计模式详解
前言：
Android开发的设计模式，基本设计思想源于java的设计模式，java的设计模式有N多种，据不完全统计，迄今为止，网络出现最频繁的大概有23种。Java只是一门开发语言，学会并掌握这门语言进行代码编写，这是每个程序员必修的课程，但如何写出高质量、易维护和复用性强的代码，那就体现出程序员的层次和水平了。设计模式的出现就是为了解决这些问题。
开始学习设计模式的时候，我们通常都有种将简单问题复杂化的感觉，明明一个类N行代码就能完成的事情，干嘛非要创建几个类？又抽象又难理解的。后来随着开发经验的增长，重复劳动的频繁，终有一天顿悟，体验到设计模式的妙用，方感慨万千。常言，水滴石穿，做任何事都是这样，经验和时间是最好的试金石，B哥老矣，前车之鉴，后车之师。闲言少叙，话转正题，我们介绍一下常用的设计模式。
工厂模式：
什么是工厂模式？官方有很多解释，我这里把我所理解的结合经验，诠释给大家，我不想绞尽脑汁，抽象总结出类似于古文（JAVA编程思想）那样难于理解的文字，也没那个水平言简意赅的、一针见血的总结出众生都能看懂的解释。只能笨鸟先飞、勤能补拙，从实践出真知的角度出发，抛砖引玉，供大家思考。公司有个这样一个需求，在App中要使用到LBS定位来实现某些功能。产品技术一大堆开始了需求、技术确认会，当大家讨论到定位是用百度API来实现，还是用高德来实现。大家争论不休，有人说百度定位不准，有人说高德定位不准，众说纷纭。咋办？最后，B总拍板，两个一起用，哪个好用哪个，领导拍板了，但说了又等于没说，咋办？工厂模式这时候就呼之欲出了，我两个都给你设计，代码设个开关和参数，你说用高德不爽，我改个参数，就换百度，直到领导高兴为止，于是代码就产生了。
public class test {
public static void main(String[] args) {
Location position= new LocationFactory().getInstance("xiaomi");
position.getPosition();
position.getCityName(10, 20);
}
}
class LocationFactory{
public static Location getInstance(String type){
if("baidu".equals(type)){
return new BaiduLocation();
}else {
return new XiaoMiLocation();
}
}
}
class BaiduLocation implements Location{
@Override
public void getPosition() {
// TODO Auto-generated method stub
System.out.println("通过百度定位获取到当前的经纬度是XXXXX");
}
@Override
public void getCityName(long lat, long lng) {
// TODO Auto-generated method stub
System.out.println("通过百度定位获取到当前的城市是XXXXX");
}
}
class XiaoMiLocation implements Location{
@Override
public void getPosition() {
// TODO Auto-generated method stub
System.out.println("通过小米定位获取到当前的经纬度是XXXXX");
}
@Override
public void getCityName(long lat, long lng) {
// TODO Auto-generated method stub
System.out.println("通过小米定位获取到当前的城市是XXXXX");
}
}
interface Location{
public void getPosition();
public void getCityName(long lat,long lng);
}
上面的例子，较好的阐述了工厂模式的概念。LocationFactory是一个工厂类，静态函数getInstance的参数决定了是选用百度还是高德，这样，对于调用者来说，只需要关心你是用百度还是高德即可。Location是一个接口，它抽象出高德和百度常用的函数调用。拿定位来说，基本上常用的就是根据经纬度查询地址，或者定位当前所在位置获取经纬度。当然可能还有更多有用的函数，我这里就不在列举。有了这样一个共性的接口，XiaoMiLocation和BaiduLocation通过实现它的接口就能分别满足调用者的需求。调用者就能够任意通过改变参数，来实现来自不同定位API的需求。当然，如果百度和高德不爽，你完全可以使用谷歌API，只需要构造一个GoogleLocation类并实现Location接口的方法即可。
工厂模式的应用非常广泛，比如android的bitmap中常用的BitmapFactory类，创建Bitmap对象，通常使用静态工厂方法。
单例模式：
什么是单例模式？单例模式的精髓主要在这个“单”字上，“单”就是一个，直接进入主题，我们通常使用“new”关键字创建一个对象，一旦“new”了，它就会开辟内存创建一个对象。假设我们经常反复创建的这个对象对我们来说其实都是一回事，那么我们就没必要浪费资源和时间嘛，好比，你去外地出差在某个地方至少1天，第一次你去服务台，服务台给你开了间房，你高高兴兴的拿着钥匙进房睡觉了。睡醒后出去办事。完事后，你是不是直接拿着这个钥匙直接奔你开好的房间？该不会去服务台再去开一间吧？大道至简，其实，细细想来，生活就是一种模式，只要你善于发现，你就会有意外惊喜，原来都是这样简单。
来个例子吧，枯燥的代码。
public class Room {
public static Room key;
public static void main(String[] args) {
Room room=getKey();
room.openDoor();
Room room1=getKey();
room1.openDoor();
}
public static Room getKey(){
if(key==null){
key=new Room();
}
return key;
}
public void openDoor(){
System.out.println("我打开了门......");
}
}
看看上面这个例子，是不是跟我举得宾馆的例子相似？你不管多少次拿钥匙，你都拿的是同一间房的钥匙，不会重新给你发一把，这样做，既节约了宾馆的时间，也节约了你的时间，多好啊。再引申一点说，android开发中也常常使用到单例模式，比如网络的封装，数据库的访问都用到了单利的设计模式。
观察者模式：
什么是观察者模式？一般提到原告，必然脑子立刻联想到被告，观察者和被观察者就如同原告和被告总是那么成对出现。观察者模式，又被叫做订阅模式，有订阅者和发布者。当下IPHONE6异常火爆，国内粉丝要想购买，那必须得预定，必须到它苹果官方去预定，填一大堆资料，交不交钱我不知道，反正得预定登记。等粉丝等到两眼欲穿、花儿快谢了时候，它粉墨登场了，官方以高姿态从容向预定过的粉丝发售。这苹果就是被观察者，粉丝就是观察者，观察者和被观察者之间需要建立联系，那就是登记。登记过后，被观察者拿捏火候觉得时机成熟的时候，就以权位者姿态向观察者抛出绣球，观察者迫不及待的伸出双手牢牢抓住后，满心欢喜的赞美苹果的伟大和自己的庆幸。睁大眼睛盯着目标看，期待期望结果，这就是观察者模式。
来段代码体验一把
import java.util.ArrayList;
import java.util.List;
public class MyOberver {
public static void main(String[] args) {
American american=new American();
Chinese chinese=new Chinese();
Iphone iphone=new Iphone();
System.out.println("一个美国人登记购买");
iphone.register(american);
System.out.println("一个中国人登记购买");
iphone.register(chinese);
try {
System.out.println("经过6个月的漫长等待...");
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
iphone.notifys();
}
}
/**观察者*/
class Iphone{
private List<Fensi> list=new ArrayList<Fensi>();
public void register(Fensi n){
list.add(n);
System.out.println("又一个苹果被预订了,现在总共有："+list.size()+"个人预订了...");
}
public void notifys(){
System.out.println("IPHONE 6现在高调发售...");
for (Fensi n:list) {
n.receive();
}
}
}
class American implements Fensi{
@Override
public void receive() {
// TODO Auto-generated method stub
System.out.println("美国人喊叫：嗯哼，有点贵....");
}
}
class Chinese implements Fensi{
@Override
public void receive() {
// TODO Auto-generated method stub
System.out.println("中国人：我终于买到了，高兴死了....");
}
}
interface Fensi{
public void receive();
}
运行后输出结果：
一个美国人登记购买
又一个苹果被预订了,现在总共有：1个人预订了...
一个中国人登记购买
又一个苹果被预订了,现在总共有：2个人预订了...
经过6个月的漫长等待...
IPHONE 6现在高调发售...
美国人喊叫：嗯哼，有点贵....
中国人：我终于买到了，高兴死了....
这就是观察者模式，Chinese和American都是观察者，它们继承了Fensi接口，具有了接收消息receive的能力，Iphone是被观察者，是被观察的目标，它的一举一动，都会深深的影响Fensi们的热情，观察者需要在被观察者哪里进行登记购买register，登记过后，等到时机成熟了，被观察者会主动放出信号iphone.notifys();这样，凡是登记过购买苹果6的粉丝们，都会纷纷收到取货的信息了。
代理模式：
什么是代理模式？代理模式在各类开发中运用的相当广泛，不论是j2ee，android还是ios，都能看到它的身影，所以说设计模式无处不在。代理模式，字面理解就是自己不方便做或者不能做的事情，需要第三方代替来做，最终通过第三方来达到自己想要的目的或效果。举例了：员工小李在B总公司打工，B总成天让小李加班不给加班费，小李忍受不住了，就想去法院告B总。虽然法律上允许打官司不请律师，允许自辩。但是小李第一不熟悉法律起诉的具体流程，第二嘴比较笨，人一多腿就抖得厉害。因此，小李决定去找律师帮忙打官司。找律师打官司和自己打官司相比，有相同的地方，也有不同的地方。
相同的地方在于：
1、 都需要提交原告的资料，如姓名、年龄、事情缘由、想达到的目的。
2、 都需要经过法院的取证调查，开庭争辩等过程。
3、 最后拿到审判结果。
不同地方在于：
1、 小李省事了，让专业的人做专业的事，不需要自己再去了解法院那一套繁琐复杂的流程。
2、 把握更大了。
通过上面的例子，我们注意到代理模式有几个重点。
1、 被代理的角色（小李）
2、 代理角色（律师）
3、 协议（不管是代理和被代理谁去做，都需要做的事情，抽象出来就是协议）
下面给个例子：
public class Proxy {
public static void main(String[] args) {
Employer employer=new Employer();
System.out.println("我受不了了，我要打官司告老板");
System.out.println("找律师解决一下吧......");
Protocol lawyerProxy=new LawyerProxy(employer);
lawyerProxy.register("朵朵花开");
lawyerProxy.dosomething();
lawyerProxy.notifys();
}
}
interface Protocol{
//登记资料
public void register(String name);
//调查案情，打官司
public void dosomething();
//官司完成，通知雇主
public void notifys();
}
//律师类
class LawyerProxy implements Protocol{
private Employer employer;
public LawyerProxy(Employer employer){
this.employer=employer;
}
@Override
public void register(String name) {
// TODO Auto-generated method stub
this.employer.register(name);
}
public void collectInfo(){
System.out.println("作为律师，我需要根据雇主提供的资料，整理与调查，给法院写出书面文字，并提供证据。");
}
@Override
public void dosomething() {
// TODO Auto-generated method stub
collectInfo();
this.employer.dosomething();
finish();
}
public void finish(){
System.out.println("本次官司打完了...............");
}
@Override
public void notifys() {
// TODO Auto-generated method stub
this.employer.notifys();
}
}
//雇主类
class Employer implements Protocol{
String name=null;
@Override
public void register(String name) {
// TODO Auto-generated method stub
this.name=name;
}
@Override
public void dosomething() {
// TODO Auto-generated method stub
System.out.println("我是'"+this.name+"'要告B总，他每天让我不停的加班，还没有加班费。");
}
@Override
public void notifys() {
// TODO Auto-generated method stub
System.out.println("法院裁定，官司赢了，B总需要赔偿10万元精神补偿费。");
}
}
运行后，打印如下：
我受不了了，我要打官司告老板
找律师解决一下吧......
作为律师，我需要根据雇主提供的资料，整理与调查，给法院写出书面文字，并提供证据。
我是'朵朵花开'要告B总，他每天让我不停的加班，还没有加班费。
本次官司打完了...............
法院裁定，官司赢了，B总需要赔偿10万元精神补偿费。
代码说明：
Protocol这个类就是上面所说的协议，是被代理者或者代理者共同遵守的约定。也就是说，无论是原告还是代理律师，到法院走程序，都需要做的事情。我们抽象出来，这个就是协议。
Employer这类是雇主类也称被代理者类，它遵从Protocol协议，并实现了Protocol协议的三个方法，并去分别完成了具体事情。
LawyerProxy这类是代理类，它也遵从Protocol协议，与Employer不同的是，定义了一个Employer对象，通过构造函数初始化。在实现的三个方法里，分别去调用被代理类的相同实现。就好比去模拟一个被告者，站在被告的角度上，去法院告状。也就是说LawyerProxy代理类对所有想打官司的人开放，只要有原告进来，我就帮他打官司。值得注意的是collectInfo和finish这两个函数，请律师打官司和不请律师打官司，其实都要做同样的事情（register、dosomething、notifys），但是至于为什么？刚才不是说了吗，请律师的好处是省心并且专业，他在做同样的事情前提下，还会收集对你有利的证据和资料（collectInfo），以及后续事情的处理（finish）。
上面就是最普通的代理模式，引申一点，我们看到，对于被告来说，必须创建一个Employer类，并实例化后传参给LawyerProxy代理类，这样做，是不是暴漏了Employer？如果隐藏一下，对于被告来说，更智能傻瓜一点，该怎么做呢？
public class Proxy {
public static void main(String[] args) {
//Employer employer=new Employer();
System.out.println("我受不了了，我要打官司告老板");
System.out.println("找律师解决一下吧......");
Protocol lawyerProxy=new LawyerProxy("朵朵花开");
lawyerProxy.dosomething();
lawyerProxy.notifys();
}
}
interface Protocol{
//登记资料
public void register(String name);
//调查案情，打官司
public void dosomething();
//官司完成，通知雇主
public void notifys();
}
//律师类
class LawyerProxy implements Protocol{
private Employer employer;
public LawyerProxy(String name){
if(name==null) {
System.out.println("谁告状？逗我玩呢吧？");
return;
}
if(employer==null) employer=new Employer();
register(name);
}
@Override
public void register(String name) {
// TODO Auto-generated method stub
this.employer.register(name);
}
public void collectInfo(){
System.out.println("作为律师，我需要根据雇主提供的资料，整理与调查，给法院写出书面文字，并提供证据。");
}
@Override
public void dosomething() {
// TODO Auto-generated method stub
collectInfo();
this.employer.dosomething();
finish();
}
public void finish(){
System.out.println("本次官司打完了...............");
}
@Override
public void notifys() {
// TODO Auto-generated method stub
this.employer.notifys();
}
}
//雇主类
class Employer implements Protocol{
String name=null;
@Override
public void register(String name) {
// TODO Auto-generated method stub
this.name=name;
}
@Override
public void dosomething() {
// TODO Auto-generated method stub
System.out.println("我是'"+this.name+"'要告B总，他每天让我不停的加班，还没有加班费。");
}
@Override
public void notifys() {
// TODO Auto-generated method stub
System.out.println("法院裁定，官司赢了，B总需要赔偿10万元精神补偿费。");
}
}
看到没new LawyerProxy("朵朵花开")，只需要给代理类传入简单的名字，隐含了Employer类，代理类就会自动去创建一个Employer实例，模拟一个用户继续替你完成打官司的事情。
篇幅有限，设计模式有很多种，以上列举了常用的几种，也是最常用最基础的几种，希望大家能够理解并掌握，如有兴趣，请参考《设计模式之禅》这本书，个人觉得不错。
