01：工厂模式基础使用

创建型模式对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。其隐藏了类的实例的创建细节。包括简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。
工厂模式并不是一个独立的设计模式，而是三种功能接近的设计模式(简单工厂模式、工厂方法模式、抽象工厂模式)的统称。

工厂模式举例

创建对象如果需要一系列的初始化操作，一般来说可以写在构造函数里，不过这样的话会导致构造函数的代码变得太长，降低程序的可读性。所以，我们可以增加一个特殊的类，即工厂类，用来负责对象的创建工作。

假设我们需要一个被广泛引用的“口罩类”，其初始化的代码也比较复杂：

public class Mask{
  // 构造函数
  public Mask(){
    // ...
    // 100行初始化代码k
  }
}

简单工厂模式

1. 我们可以构建一个“口罩工厂”专门负责创建口罩对象，把口罩的初始化代码迁移到工厂类的创建方法中：

public class Mask{
  public Mask();
}

// 口罩工厂
public class MaskFactoy{
  public Mask createMask(){
    Mask mask = new Mask();
    // ...
    // 100行初始化代码
    retrun mask;
  }
}

2.1 假设口罩类存在子类，可以将口罩类作为抽象接口，子类(高级口罩和低级口罩)实现接口。

public interface IMask{
  void show();
} 

public class HighEndMask implements IMask{
  @Override
  public void show(){
    System.out.println("我是高端口罩");
  }
}

public class LowEndMask implements IMask{
  @Override
  public void show(){
    System.out.println("我是低端口罩");
  }
}

2.2 创建工厂

public class MaskFactory{
  public IMask createMask(type){
    IMask mask = null;
    if("高端口罩".equals(type)){
      mask = new HighEndMask();
      // ...
      // HighEndMask 的100行初始化代码
    }else if("低端口罩".equals(type)){
      mask = new LowEndMask();
      // ...
      // LowEndMask 的100行初始化代码
    }
    return mask;
  }
}

2.3 只要传入对应的类型名称，就可以创建相应的口罩对象：

public class Test{
  public staic void main(String[]){
    MaskFactory factory = new MaskFactory();
    IMask maskA = factory.createMask("高端口罩");
    IMask maskB = factory.createMask("低端口罩");
    maskA.show();
    maskB.show();
  }
}

工厂方法模式

如果增加新的口罩子类，口罩工厂的创建方法中就要新增if-else判断，不符合面向对象的开发-封闭原则。所以我们可以为每个口罩子类创建对应的工厂子类，这些工厂子类分别实现抽象的工厂接口。(多态)

开放-封闭原则，即在程序中对扩展开放，对修改封闭。如果每次业务改动都要新增if-else，就涉及对旧有代码的修改，容易出错，可读性也不好。

1.2 所以我们可以修改简单工厂模式中2.2的内容，重构一下工厂类的逻辑：

public interface IMaskFactory{
  IMask createMask(); 
}

public class HighEndMaskFactory implements IMaskFactory{
  @Override
  public IMask createMask(){
    IMask mask = new HighEndMask(); 
    // ...
    // 100行初始化代码
    return mask;
  }
}

public class LowEndMaskFactory implements IMaskFactory{
  @Override
  public IMask createMask(){
    IMask mask = new LowEndMask();
    // ...
    // 100行初始化代码
    return mask;
  }
}

1.2 使用

public class Test{
  public static void main(String[]){
    IMaskFactory factoryA = new HighEndMaskFactory();
    IMask maskA = factoryA.createMask();
    maskA.show();
    IMaskFactory factoryB = new LowEndMaskFactory();
    IMask maskB = factoryB.createMask();
    maskB.show();
  }
}

抽象工厂模式

如果需要创建子类越来越多，不只有口罩，还有防毒面具、防护服之类的，难道每一个子类都需要对应一个工厂吗？
解决：如果带创建的产品非常多，不需要为每个产品配上一个工厂类（比如高端口罩，低端口罩，高端防护服，低端防护服），而是可以把这些产品进行分组（把产品分为高端组和低端组，不同产品有工厂类的不同方法来创建）。

1.1 创建产品类，口罩和防护服

// 口罩接口和两个实现子类
public interface IMask{
  void showMask();
}

public class HighEndMask implements IMask{
  @Override
  public void showMask(){
    System.out.println("我的高端口罩");
  }
}

public class LowEndMask implements IMask{
  @Override
  public void showMask(){
    System.out.println("我的低端口罩");
  }
}

// 防护服接口和两个实现子类
public interface IProjectiveSuit{
  void showSuit();
}

public class HighEndProjectSuit implements IProjectiveSuit{
  @Override
  public void showSuit(){
    System.out.println("我的高端防护服");
  }
}

public class LowEndProjectSuit implements IProjectiveSuit{
  @Override
  public void showSuit(){
    System.out.println("我的低端防护服");
  }
}

1.2 工厂类

// 区别在此，工厂方法模式创建 IMaskFactory 接口，分别实现高端口罩与低端口罩两个工厂子类
// 而抽象工厂模式，也是抽象出高端和低端两个工厂子类，在里面实现创建口罩和防护服类的方法
public interface IFactory{
  void createMask();
  void createSuit();
}

public class HighEndFactory implements IFactory{
  @Override
  public IMask createMask(){
    IMask mask = new HighEndMask();
    // ...
    // 100行初始化代码
    return mask;
  }

  @Override
  public IProjectiveSuit createSuit(){
    IProjectiveSuit suit = new HighEndProjectSuit();
    // ...
    // 100行初始化代码
    return suit;
  }
}
public class LowEndFactory implements IFactory{
  @Override
  public IMask createMask(){
    IMask mask = new LowEndMask();
    // ...
    // 100行初始化代码
    return mask;
  }

  @Override
  public IProjectiveSuit createSuit(){
    IProjectiveSuit suit = new LowEndProjectSuit();
    // ...
    // 100行初始化代码
    return suit;
  }
}

1.3 使用

public class Test{
  public void Main(String[]){
    // 创建工厂
    IFactory factoryA = new HighEndFactory();
    IFactory factoryB = new LowEndFactory();
    // 创建高端口罩，高端防护服
    IMask maskA = factoryA.createMask();
    IProjectiveSuit suitA = factoryA.createSuit();
    // 创建低端口罩，低端防护服
    IMask maskB = factoryB.createMask();
    IProjectiveSuit suitB = factoryB.createSuit();

    // 使用
    maskA.showMask();
    maskB.showMask();
    suitA.showSuit();
    maskB.showSuit();

  }
}

参考

设计模式教程
[微信公众号：程序员小灰]