Android应用开发Android 常见的设计模式

Android应用开发Android 常见的设计模式

白羽2019-03-04来源 ：网络阅读 227评论 0

摘要：本文将带你了解Android应用开发Android 常见的设计模式，希望本文对大家学Android有所帮助。

 

    本文将带你了解Android应用开发Android 常见的设计模式，希望本文对大家学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 {
    List> mObservers = new ArrayList>();
   
    public void register(Observer observer) {
    if (observer == null) {
    throw new NullPointerException(observer == null);
    }
    synchronized (this) {
    if (!mObservers.contains(observer))
    mObservers.add(observer);
    }
    }
   
    public synchronized void unregister(Observer observer) {
    mObservers.remove(observer);
    }
   
    public void notifyObservers(T data) {
    for (Observer observer : mObservers) {
    observer.onUpdate(this, data);
    }
    }
   
    }
    而我们的观察者只需要实现一个观察者的接口Observer,该接口也是泛型的
    public interface Observer {
    void onUpdate(Observable observable,T data);
    }
    一旦订阅的主题发生了变化，就会调用该接口
      用一下，我们定义一个天气变化的主题，也就是被观察者，再定义两个观察者来观察天气的变化，一旦变化了就打印出天气的情况，注意，一定要用register方法来注册，否则观察者收不到变化的信息，而一旦不感兴趣，就可以调用unregister方法
    public class Main {
    public static void main(String [] args){
    Observable observable=new Observable();
    Observer observer1=new Observer() {
    @Override
    public void onUpdate(Observable observable, Weather data) {
    System.out.println(观察者1：+data.toString());
    }
    };
    Observer observer2=new Observer() {
    @Override
    public void onUpdate(Observable 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事件都有观察者模式
   
        

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标移动开发之Android频道！