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.youkuaiyun.com/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;
}

####浅拷贝和深拷贝
@Override
public 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;
}

@Override
public 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万元精神补偿费。");
       }

}

感悟

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