Android中常用的几种设计模式-待完善

一.单例模式

1. 常用的写法：双重检查，synchronized同步，volatile修饰单例。

代码：

public class Singleton {
      private static volatile Singleton instance = null;
      private Singleton() {
      }
      public static Singleton getInstance() {
             if (instance == null) {
                   synchronized (Singleton.class) {
                         if (instance == null) {
                               instance = new Singleton();
                         }
                   }
             }
             return instance;
      }
}

2.静态内部类模式：

public class Singleton {
    private static class SingletonHolder {
       private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
          return SingletonHolder.INSTANCE;
    }
}

对于内部类SingletonHolder，它是一个饿汉式的单例实现，在SingletonHolder初始化的时候会由ClassLoader来保证同步，使INSTANCE是一个真·单例。
同时，由于SingletonHolder是一个内部类，只在外部类的Singleton的getInstance()中被使用，所以它被加载的时机也就是在getInstance()方法第一次被调用的时候。
——它利用了ClassLoader来保证了同步，同时又能让开发者控制类加载的时机。从内部看是一个饿汉式的单例，但是从外部看来，又的确是懒汉式的实现。

二.建造者模式：Builder

定义一个静态内部类Builder，内部的成员变量和外部类一样
Builder类通过一系列的方法用于成员变量的赋值，并返回当前对象本身（this）
Builder类提供一个build方法或者create方法用于创建对应的外部类，该方法内部调用了外部类的一个私有构造函数，该构造函数的参数就是内部类Builder
外部类提供一个私有构造函数供内部类调用，在该构造函数中完成成员变量的赋值，取值为Builder对象中对应的值

三.观察者模式 Observer（观察者），Observable(被观察者)

1.被观察者：Observable

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

2.观察者：Observer

public interface Observer<T> {
    void onUpdate(Observable<T> observable,T data);
}

3.调用

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

Android中的广播也是观察者模式。

扫描二维码关注公众号，回复： 1554141 查看本文章

四.工厂者模式：Factory

1.创建抽象产品类，定义公共接口：

  public interface Product {
        void show();
    }

2.创建具体产品类，实现Product接口：

 public class ProductA implements Product {
        @Override
        public void show() {
            System.out.println("product A");
        }
    }

public class ProductB implements Product {
        @Override
        public void show() {
            System.out.println("product B");
        }
    }

3.创建工厂类，创建具体的产品

 public class Factory {
          public static Product create(String productName) {
              Product product = null;
              //通过switch语句控制生产哪种商品
              switch (productName) {
                  case "A":
                      product = new ProductA();
                      break;
                  case "B":
                      product = new ProductB();
                      break;
              }
              return product;
          }
      }

第3步也可以通过反射得到具体的产品类：

 public Product create(Class<? extends Product> clazz) {
                   Product product = null;
                   try {
                         product = clazz.newInstance();
                   } catch (InstantiationException e) {
                         e.printStackTrace();
                   } catch (IllegalAccessException e) {
                         e.printStackTrace();
                   }
                   return product;
             }

测试：
Factory.create("A").show();//生产ProductA

Factory.create(ProductB.class).show();//生产ProductB

未完待续.....，有问题欢迎指出，谢啦

Android中常用的几种设计模式-待完善

猜你喜欢