Android 常见的设计模式

单例模式：分为懒汉式和饿汉式
EventBus就是使用的单例模式，双重锁+volatile。

工厂方法模式：

定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
在工厂方法模式中，核心的工厂类不再负责所有的对象的创建，而是将具体创建的工作交给子类去做。这个核心类则摇身一变，成为了一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个类应当被实例化这种细节。
首先：定义一个接口
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 SubwayStrategy implements Strategy{    
    
    @Override    
    public void travel() {    
        System.out.println("subway");    
    }    
    
}   
还需要一个包装类，来调用接口
public class TravelContext {    
    Strategy strategy;    
    
    public Strategy getStrategy() {    
        return strategy;    
    }    
    
    public void setStrategy(Strategy strategy) {    
        this.strategy = strategy;    
    }    
    
    public void travel() {    
        if (strategy != null) {    
            strategy.travel();    
        }    
    }    
}    
测试：
public class Main {    
    public static void main(String[] args) {    
        TravelContext travelContext=new TravelContext();    
        travelContext.setStrategy(new PlaneStrategy());    
        travelContext.travel();    
        travelContext.setStrategy(new WalkStrategy());    
        travelContext.travel();    
        travelContext.setStrategy(new SubwayStrategy());    
        travelContext.travel();    
    }    
}    
如果以后要增加别的出行方式，只要继承接口即可，不需要修改现有的类
android中的使用：bitmapFactory

抽象工厂模式：
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
在以下情况下，适用于工厂方法模式：
(1) 当一个类不知道它所必须创建的对象的类的时候。
(2) 当一个类希望由它的子类来指定它所创建的对象的时候。

(3) 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

建造者模式：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
与抽象工厂的区别：在建造者模式里，有个指导者，由指导者来管理建造者，用户是与指导者联系的，指导者联系建造者最后得到产品。即建造模式可以强制实行一种分步骤进行的建造过程。
建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。
public class Person {    
    private String name;    
   
    private Person(Builder builder) {    
        this.name=builder.name;       
    }    
    public String getName() {    
        return name;    
    }    
    public void setName(String name) {    
        this.name = name;    
    }    
    
    static class Builder{    
        private String name;    
         
        public Builder name(String name){    
            this.name=name;    
            return this;    
        }    
        public Person build(){    
            return new Person(this);    
        }    
    }    
}    
从上边代码我们可以看到我们在Builder类中定义了一份跟Person类一样的属性，通过一系列的成员函数进行赋值，但是返回的都是this,最后提供了一个build函数来创建person对象，对应的在Person的构造函数中，传入了Builder对象，然后依次对自己的成员变量进行赋值。此外，Builder的成员函数返回的都是this的另一个作用就是让他支持链式调用，使代码可读性大大增强
于是我们就可以这样创建Person对象
Person.Builder builder=new Person.Builder();    
Person person=builder    
        .name("张三")    
        .age(18)    
        .height(178.5)    
        .weight(67.4)    
        .build();  
Android中builder模式很多，例如：alertDialog的builder模式、gsonbuilder、okhttp的builder链式调用
总结如下：
1、定义一个静态内部类Builder，内部成员变量跟外部一样
2、Builder通过一系列方法给成员变量赋值，并返回当前对象（this）
3、Builder类内部提供一个build方法方法或者create方法用于创建对应的外部类，该方法内部调用了外部类的一个私有化构造方法，该构造方法的参数就是内部类Builder
4、外部类提供一个私有化的构造方法供内部类调用，在该构造函数中完成成员变量的赋值

代理模式：
为其他对象提供一种代理以控制对这个对象的访问
所谓代理，就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

适配器模式：

观察者模式：

定义对象间一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
主要包括四个部分：
　　1. Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
　　2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。
　　3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
　　4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。
其实就是我们无需每时每刻关注我们感兴趣的东西，我们只需要订阅它即可，一旦我们订阅的事务有变化了，被订阅的事务就会即时的通知我们
我们来看一下观察者模式的组成：
观察者，我们称它为Observer，有时候我们也称它为订阅者，即Subscriber
被观察者，我们称它为Observable，即可以被观察的东西，有时候还会称之为主题，即Subject

举例：

public class Weather {    
    private String description;    
    
    public Weather(String description) {    
        this.description = description;    
    }    
    
    public String getDescription() {    
        return description;    
    }    
    
    public void setDescription(String description) {    
        this.description = description;    
    }    
    
    @Override    
    public String toString() {    
        return "Weather{" +    
                "description='" + description + '\'' +    
                '}';    
    }    
}    
然后定义我们的被观察着，我们希望它能够通用，所以定义成泛型，内部应该暴露出register和unRegister供观察者订阅和取消订阅，至于观察者的保存，我们用ArrayList即可，另外，当主题发生变化的时候，需要通知观察者来做出响应，还需要一个notifyObservers方法，具体实现如下：
public class Observable<T> {    
    List<Observer<T>> mObservers = new ArrayList<Observer<T>>();    
    
    public void register(Observer<T> observer) {    
        if (observer == null) {    
            throw new NullPointerException("observer == null");    
        }    
        synchronized (this) {    
            if (!mObservers.contains(observer))    
                mObservers.add(observer);    
        }    
    }    
    
    public synchronized void unregister(Observer<T> observer) {    
        mObservers.remove(observer);    
    }    
    
    public void notifyObservers(T data) {    
        for (Observer<T> observer : mObservers) {    
            observer.onUpdate(this, data);    
        }    
    }    
    
}    
而我们的观察者只需要实现一个观察者的接口Observer,该接口也是泛型的
public interface Observer<T> {    
    void onUpdate(Observable<T> observable,T data);    
}    
一旦订阅的主题发生了变化，就会调用该接口
用一下，我们定义一个天气变化的主题，也就是被观察者，再定义两个观察者来观察天气的变化，一旦变化了就打印出天气的情况，注意，一定要用register方法来注册，否则观察者收不到变化的信息，而一旦不感兴趣，就可以调用unregister方法
public class Main {    
    public static void main(String [] args){    
        Observable<Weather> observable=new Observable<Weather>();    
        Observer<Weather> observer1=new Observer<Weather>() {    
            @Override    
            public void onUpdate(Observable<Weather> observable, Weather data) {    
                System.out.println("观察者1："+data.toString());    
            }    
        };    
        Observer<Weather> observer2=new Observer<Weather>() {    
            @Override    
            public void onUpdate(Observable<Weather> observable, Weather data) {    
                System.out.println("观察者2："+data.toString());    
            }    
        };    
    
        observable.register(observer1);    
        observable.register(observer2);    
    
    
        Weather weather=new Weather("晴转多云");    
        observable.notifyObservers(weather);    
    
        Weather weather1=new Weather("多云转阴");    
        observable.notifyObservers(weather1);    
    
        observable.unregister(observer1);    
    
        Weather weather2=new Weather("台风");    
        observable.notifyObservers(weather2);    
    
    }    
}    
输出也没有问题
观察者1：Weather{description=’晴转多云’}
观察者2：Weather{description=’晴转多云’}
观察者1：Weather{description=’多云转阴’}
观察者2：Weather{description=’多云转阴’}
观察者2：Weather{description=’台风’}

Android中的观察者模式：onClick、EventBus的register、unregister、post事件都有观察者模式