Java 设计模式（Design Patterns）（一）

设计模式的分类

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

我只讲我用的多的，用的多的印象深刻，知道怎么讲，用的少的，不知道怎么讲。只讲我熟练的。

一、单例模式

单例模式，我想应该做过开发的人都用过。

懒汉式（用的时候初始化，延迟加载）

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

这里在懒汉式的单例模式中加上了同步锁synchronized，所以，这是线程安全的，但是，也是因为锁，所以造成的效率低，可以根据不同实际情况判断是否需要加同步锁。

饿汉式（加载类的时候直接初始化）

public class MySocket{
    private static MySocket instance = new MySocket();
    private MySocket(){}
    public static MySocket getInstance(){
        return instance;
    }
}

双重校验锁

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

这里的双重校验锁，其实就是我这里的线程安全懒汉式的升级版本，双重校验锁很多开源框架都是用的这种单例，比方说：EventBus。关于单例模式的其他变种我就不说了。单例模式的最终目的，就是全局单例，一个项目不论哪里调用这个类都是引用的同一个对象。

二、工厂模式

/**
 * Author: 海晨忆.
 * Date: 2017/12/21
 * Desc:
 */
public class FragmentFactory {
  public static BaseFragment createFragment(Class<? extends BaseFragment> clz) {
    return createFragment(clz, null);
  }

  public static BaseFragment createFragment(Class<? extends BaseFragment> clz, Bundle bundle) {
    if (HomeFragment.class == clz) {
      return new HomeFragment();
    } else if (MyClothesFragment.class == clz) {
      return new MyClothesFragment();
    } else if (WardrobeStructureFragment.class == clz) {
      return new WardrobeStructureFragment();
    } else if (WifiFragment.class == clz) {
      return new WifiFragment();
    } else if (WardrobeConfigFragment.class == clz) {
      return new WardrobeConfigFragment();
    } else if (ShowFragment.class == clz) {
      return new ShowFragment();
    } else {
      throw new NullPointerException("not found fragment");
    }
  }

  public static <T extends DialogFragment> T createDialogFragment(Class<T> clz) {
    return createDialogFragment(clz, null);
  }

  @SuppressWarnings("unchecked")
  private static <T extends DialogFragment> T createDialogFragment(Class<T> clz, Bundle bundle) {
    if (clz == IconDialogFragment.class) {
      return (T) new IconDialogFragment();
    } else if (clz == PasswordDialogFragment.class) {
      return (T) PasswordDialogFragment.newInstance();
    } else {
      throw new NullPointerException("not found fragment");
    }
  }
}

这个fragment工厂类，就是我项目里面用到的。常用的工厂模式就是静态工厂，利用static方法，我这里的工厂就是静态工厂。我们常说的工厂方法对应的这里是什么呢？其实，工厂方法也是一个普通的方法，对应的这里就是createFragment(Class<? extends BaseFragment> clz)。工厂模式什么时候用呢？在需要大量类似的数据的时候（个人观点），Android里面，工厂方法用的最多的就是创建Fragment。

三、抽象工厂模式

public interface IFragmentFactory{
    BaseFragment createFragment();
}

public class HomeFactory implements IFragmentFactory{
    @Override
    public BaseFragment createFragment(){
        return new HomeFragment();
    }
}

public class WifiFragment implements IFragmentFactory{
    @Override
    public BaseFragment createFragment(){
        return new WifiFragment();
    }
}

我把上面的静态工厂类，改成了抽象工厂类，就是上面的代码。就是有一个工厂接口或者抽象的工厂类，然后创建不同的工厂类去实现这个接口，实现对应的类，返回你需要的东西

四、建造者模式

我之前写Luban源码解析的时候就讲过建造者模式，可以去看一下，就在源码解析的一开始

package com.haichenyi.mytakephoto;

/**
 * Author: 海晨忆
 * Date: 2018/3/6
 * Desc:
 */
public class DataBean {
  private String name;
  private int age;
  private String sex;

  public DataBean(Builder builder) {
    this.name = builder.name;
    this.age = builder.age;
    this.sex = builder.sex;
  }

  public static class Builder {
    private String name;
    private int age = 20;
    private String sex = "男";

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

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

    public Builder setSex(String sex) {
      this.sex = sex;
      return this;
    }

    public DataBean build() {
      return new DataBean(this);
    }
  }
}

上面的代码就是一个DataBean类，用建造者模式创建。要是还是不懂，你可以理解成，我们常常在写bean类的时候，往往要写set方法，你可以理解成，把set方法写在Builder里面，在Builder里面赋好值之后，在我们bean类的构造方法里面传递过来就可以了。

五、原型模式

这个模式，我没用到过，网上搜的是，类似于拷贝功能。可以自行搜索。