android中的用到的设计模式

设计模式

目录

• 单利模式
• 工厂模式
• 观察者模式
• 建造者模式
• 动态代理模式

一 单利模式

用EventBus的建立方式为例子

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

构造方法私有,静态方法获得实例 volatile 关键字:告诉不一样的线程 不要拿寄存器的值,要拿主存的值 synchronized 关键字:能够同步与 方法 或者 代码块

优化点

• 优势

1. 提供了对惟一实例的受控访问；
2. 因为在系统内存中只存在一个对象，所以能够节约系统资源，对于一些须要频繁建立和销毁的对象单例模式无疑能够提升系统的性能；
3. 能够根据实际状况须要，在单例模式的基础上扩展作出双例模式，多例模式；

• 缺点

1. 单例类的职责太重，里面的代码可能会过于复杂，在必定程度上违背了“单一职责原则”。
2. 若是实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将致使对象状态的丢失。

二 工厂模式

用汽车为例子

1. 先建一个 Car 的抽象类

public abstract class Call{
    // 启动 开车
    public abstract Start();
}
复制代码

2. 好比 有 奥迪, 有宝马...

// 奥迪车类
public AodiCar extends Car{
     public void Start(){
         system.out.println("奥迪车启动了")
     };
}

// 宝马车类
public BWMCar extends Car{
     public void Start(){
         system.out.println("宝马车启动了")
     };
}
复制代码

3.建一个工厂生产

public class CarFactory{
   //此处传递过来的参数是 包.类名
   public static Car getInstance(Class  clazz) {       
	         
	         Car car = null;
	         
	         try {
	             //利用反射 实例化对象
	             car = (Car)Class.forName(clazz.getName).newInstance();       
	             
	        }catch(Exception e) {
	            
	             e.printStackTrace();
	         }
	         return car;
	     }
}
复制代码

4. 测试

Car aodiCar= CarFactory.getInstance(AodiCar.class)
Car bmwCar= CarFactory.getInstance(BWMCar.class)
aodiCar.start();
bmwCar.start();
复制代码

5.场景

好比Retrfit中有不少个Service 你彻底能够用工厂模式作
复制代码

三 观察者模式

场景不少, 好比EventBus , Rxjava 等等

须要知道的东西

• 抽象被观察者角色:
  也就是一个抽象主题，它把全部对观察者对象的引用保存在一个集合中，每一个主题均可以有任意数量的观察者。抽象主题提供一个接口，能够增长和删除观察者角色。通常用一个抽象类和接口来实现。
• 抽象观察者角色:
  为全部的具体观察者定义一个接口，在获得主题通知时更新本身
• 具体被观察者角色：
  也就是一个具体的主题，在集体主题的内部状态改变时，全部登记过的观察者发出通知
• 具体观察者角色:
  实现抽象观察者角色所须要的更新接口，一边使自己的状态与制图的状态相协调。

开始写例子 好比银行向每一个客户发送推广广告

定义一个抽象被观察者接口

public interface Observerable{
     // 用来注册观察者 也就是注册用户
	void register(Observe o); 
    // 移除观察者   也就是移除用户
	void unRegister(Observe o) 
    //通知   也就是发送推广广告
	void notifyAll();        
}
复制代码

定义一个抽象观察者

public interface Observe{
    // 收到消息 也就是收到银行的广告通知
	void recivered(String msg);  
}
复制代码

定义一个抽象被观察者接口的实现类

public class ObserverableImpl implements ObserveAble{
    // 这个是存贮全部注册过的观察者
	private ArrayList<Observe> list;  
    // 记录要下发的消息 
	private String message;   
	public ObserverableImpl(){
		list = new ArrayList();
	}

    // 添加
	@Override
	public void register(Observe o){  
		if(!list.contains(o)){
			list.add(o);
		}
	}

    //移除
	@Override
	public void unRegister(Observe o){ 
		if(list.contains(o)){
			list.remove(o);
		}
	}
	
     //通知
	@Override
	public void notifyAll(){  
		for(int i=0;i++;i<list.size()){
			list.get(i).recivered(message); // 而后调用 观察者的方法
		}
	}
	
	// 给外界暴露的方法 设置消息而且通知
	public void setInfomation(String s) {  
		this.message = s;
		//消息更新，通知全部观察者
		notifyAll();
	}

	
}
复制代码

具体观察者实现类

public class  ObserveImpl(){
    private String name;
	public ObserveImpl(String name){
	    this.name=name;
	}
	@Override
	public void recivered(String msg){
		//收到消息 去作本身的事情	
		 System.out.println(name + " 收到推送过来的消息： " + message);
	}
}
复制代码

测试

// 银行
   Observerable obserebale = new ObserverableImpl();
   //用户
   Observer xiaoming = new ObserveImpl("小明");
   Observer xiaohong = new ObserveImpl("小红");
  obserebale.register(userZhang);
  obserebale.register(userLi);
  // 调用Observerable的发送消息
 obserebale.setInfomation("你中奖100w"); 
复制代码

打印的日志是:

小明收到推送的消息你中奖100w
小红收到推送的消息你中奖100w
复制代码

四 建造者模式 (builder模式)

典型的例子 (不少)

• android 中的dialog(最典型了)
• okhttp 的 OkHttpClient.Builder 和 Request.Builder
• EventBus 的 EventBusBuilder

例子

public class Person {
    private String mName;
    private int mAge;
    private String mAddress;

    private Person(Builder builder) {
        mName = builder.mName;
        mAge = builder.mAge;
        mAddress = builder.mAddress;
    }


    public static final class Builder {
        private String mName;
        private int mAge;
        private String mAddress;

        public Builder() {
        }

        public Builder setName(String name) {
            mName = name;
            return this;
        }

        public Builder setAge(int age) {
            mAge = age;
            return this;
        }

        public Builder setAddress(String address) {
            mAddress = address;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }
}
复制代码

使用

Person person = new Person.Builder().setAddress("河北邯郸").setName("nzy").setAge(27).build();
复制代码

Studio 插件 能够一键生成builder格式代码 InnerBuilder 插件

优缺点(参考)

• 优势：
  1. 不须要知道产品内部的组成细节，产品与建立过程解耦
  2. 分步组装产品，使得产品的建立过程更精细更清晰
  3. 容易扩展，新产品只须要新建一个建造者便可
• 缺点：
  1. Builder模式建立的产品差别性小，使用范围受限制
  2. 不一样的产品会产生多个建造者和指挥者

五 动态代理模式

他的特征是代理类与委托类有一样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及过后处理消息等。

场景:

android中的hook技术,有些插件化技术,spring中经过动态代理实现了aop(切面编程),retrofit.create

以retrofit为例子

须要代理的类(ApiService)

public interface ApiService
	{
		@GET("/heiheihei")
		public void add(int a, int b);

	}
}
复制代码

代理类

class MyInvocationHandler implements InvocationHandler{

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Integer a = (Integer) args[0];
        Integer b = (Integer) args[1];
        System.out.println("方法名：" + method.getName());
        System.out.println("参数：" + a + " , " + b);
        GET get = method.getAnnotation(GET.class);
        System.out.println("注解：" + get.value());
        return null;
    }
}
复制代码

开始代理

ApiService service = (ApiService) Proxy.newProxyInstance(ApiService.class.getClassLoader(), new Class<?>[]{ITest.class},new MyInvocationHandler())
复制代码

六 装饰着模式

动态地为一个对象添加一些额外的职责，若要扩展一个对象的功能，装饰者提供了比继承更有弹性的替代方案。

场景: I/o流

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("..")));
复制代码

构成

• 抽象构件类（Component）：给出一个抽象的接口，用以规范准备接收附加责任的对象
• 具体构件类（ConcreteComponent）：定义一个具体的准备接受附加责任的类，其必须实现Component接口。
• 装饰者类（Decorator）：持有一个构件（Conponent）对象的实例，并定义一个和抽象构件一致的接口。
• 具体装饰者类（Concrete Decoratator）：定义给构件对象“贴上”附加责任。

参考文章

• 设计模式 之 装饰者（Decorator）模式
• 透过Retrofit使用看其源码设计模式
• 单例模式（Singleton）- 最易懂的设计模式解析