Android中的设计模式

参考文章

1，Android开发中常见的设计模式
http://www.cnblogs.com/android-blogs/p/5530239.html
2，Android源码设计模式分析开源项目
https://github.com/simple-android-framework-exchange/android_design_patterns_analysis
3、 Android 设计模式
http://blog.csdn.net/banketree/article/details/24985607
4、《Android深入透析》之常用设计模式经验谈
https://my.oschina.net/u/2249934/blog/343441
5、设计模式（有23种模式的应用实例、何时使用等说明）
http://www.runoob.com/design-pattern/design-pattern-tutorial.html
6、传智播客设计模式视频教程
链接：http://pan.baidu.com/s/1i3QNjHN 密码：ezyn
7、Android学习——ActivityManager与Proxy模式的运用
http://www.cnblogs.com/bastard/archive/2012/05/25/2517522.html

单例模式

private static volatile EventBus defaultInstance;public static EventBus getDefault() {    if (defaultInstance == null) {        synchronized (EventBus.class) {            if (defaultInstance == null) {                defaultInstance = new EventBus();            }        }    }    return defaultInstance;}

Build模式

AlertDialog.Builder builder=new AlertDialog.Builder(this);AlertDialog dialog=builder.setTitle("标题")        .setIcon(android.R.drawable.ic_dialog_alert)        .setView(R.layout.myview)        .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) {            }        })        .create();dialog.show();

观察者模式

private List<OnScrollListener> mScrollListeners;public void addOnScrollListener(OnScrollListener listener) {    if (mScrollListeners == null) {        mScrollListeners = new ArrayList<OnScrollListener>();    }    mScrollListeners.add(listener);}public void removeOnScrollListener(OnScrollListener listener) {    if (mScrollListeners != null) {        mScrollListeners.remove(listener);    }}public void clearOnScrollListeners() {    if (mScrollListeners != null) {        mScrollListeners.clear();    }}

原型模式

public Object clone() {    return new Bundle(this);} public Bundle(Bundle b) {    super(b);    mHasFds = b.mHasFds;    mFdsKnown = b.mFdsKnown;}####浅拷贝和深拷贝@Overridepublic Object clone(){//浅拷贝    Person person=null;    try {        person=(Person)super.clone();        person.name=this.name;        person.weight=this.weight;        person.height=this.height;        person.age=this.age;        person.hobbies=this.hobbies;    } catch (CloneNotSupportedException e) {        e.printStackTrace();    }    return person;}@Overridepublic Object clone(){//深拷贝    Person person=null;    try {        person=(Person)super.clone();        person.name=this.name;        person.weight=this.weight;        person.height=this.height;        person.age=this.age;        person.hobbies=(ArrayList<String>)this.hobbies.clone();    } catch (CloneNotSupportedException e) {        e.printStackTrace();    }    return person;}//测试代码public class Main {    public static void main(String [] args){        Person p=new Person();        p.setAge(18);        p.setName("张三");        p.setHeight(178);        p.setWeight(65);        ArrayList <String> hobbies=new ArrayList<String>();        hobbies.add("篮球");        hobbies.add("编程");        hobbies.add("长跑");        p.setHobbies(hobbies);        System.out.println(p);        Person p1= (Person) p.clone();        System.out.println(p1);        p1.setName("李四");        p1.getHobbies().add("游泳");        System.out.println("clone test:"+p);//这一句浅拷贝和深拷贝打印有区别，浅拷贝只是拷贝一个印有（没有生成新的对象，原对象和拷贝对象指向的是同一个对象），深拷贝会创建一个新的对象        System.out.println(p1);    }}//浅拷贝和深拷贝打印的只有"clone test:"+p 这一句有别//浅拷贝clone test:Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑, 游泳]}//深拷贝clone test:Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑]}

策略模式

public interface Strategy {    void travel();}public class WalkStrategy implements Strategy{    @Override    public void travel() {        System.out.println("walk");    }}public class PlaneStrategy implements Strategy{    @Override    public void travel() {        System.out.println("plane");    }}

工厂模式

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

代理模式

/**什么是代理模式？代理模式在各类开发中运用的相当广泛，不论是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万元精神补偿费。");       }}

感悟

不会设计模式的程序员知识结构不完整
面向接口编程、学会使用设计模式可以显著增强程序的可扩展性、可读性