工厂模式

工厂模式也被称之为虚拟构造函数（Virtual Constructor），是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象

意图

定义用于创建对象的接口，但是让子类决定实例化哪个类。factory方法允许类将实例化推迟到子类

主要解决：接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

解释

现实世界的例子

铁匠制造武器。精灵需要精灵武器，兽人需要兽人武器。根据手头的顾客，召集合适类型的铁匠

简而言之

它提供了一种将实例化逻辑委托给子类的方法

*说

In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method—either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes—rather than by calling a constructor.
(在基于类的编程中，factory方法模式是一种创建模式，它使用factory方法来处理创建对象的问题，而不必指定将要创建的对象的确切类。这是通过调用factory方法(在接口中指定并由子类实现，或者在基类中实现并可选地由派生类重写)来实现的，而不是通过调用构造函数来实现的。)

程序代码示例

以现实世界的例子铁匠制造武器为例子，需要什么样的武器类型我们就召唤对应类型的铁匠。程序类图如下：

首先我们有一个铁匠接口（定义了一个制造武器的方法）和一些精灵铁匠、兽人铁匠实现类：

public interface Blacksmith {
  Weapon manufactureWeapon(WeaponType weaponType);
}

public class ElfBlacksmith implements Blacksmith {
  public Weapon manufactureWeapon(WeaponType weaponType) {
    return new ElfWeapon(weaponType);
  }
}

public class OrcBlacksmith implements Blacksmith {
  public Weapon manufactureWeapon(WeaponType weaponType) {
    return new OrcWeapon(weaponType);
  }
}

其次我们有一个武器接口（定义了一个获取武器类型的方法）和一些精灵武器、兽人武器实现类：

/**
 * Weapon interface.
 */
public interface Weapon {

  WeaponType getWeaponType();

}
/**
 * ElfWeapon.
 */
public class ElfWeapon implements Weapon {

  private WeaponType weaponType;

  public ElfWeapon(WeaponType weaponType) {
    this.weaponType = weaponType;
  }

  @Override
  public String toString() {
    return "Elven " + weaponType;
  }

  @Override
  public WeaponType getWeaponType() {
    return weaponType;
  }
}

/**
 * OrcWeapon.
 */
public class OrcWeapon implements Weapon {

  private WeaponType weaponType;

  public OrcWeapon(WeaponType weaponType) {
    this.weaponType = weaponType;
  }

  @Override
  public String toString() {
    return "Orcish " + weaponType;
  }

  @Override
  public WeaponType getWeaponType() {
    return weaponType;
  }
}

最后，随着顾客的到来，正确类型的铁匠被召唤出来，要求制造武器

public class App {

  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);

  private final Blacksmith blacksmith;
  
  /**
   * Creates an instance of <code>App</code> which will use <code>blacksmith</code> to manufacture 
   * the weapons for war.
   * <code>App</code> is unaware which concrete implementation of {@link Blacksmith} it is using.
   * The decision of which blacksmith implementation to use may depend on configuration, or
   * the type of rival in war.
   * @param blacksmith a non-null implementation of blacksmith
   */
  public App(Blacksmith blacksmith) {
    this.blacksmith = blacksmith;
  }
  
  /**
   * Program entry point
   * 
   * @param args command line args
   */
  public static void main(String[] args) {
    // Lets go to war with Orc weapons
    App app = new App(new OrcBlacksmith());
    app.manufactureWeapons();
    
    // Lets go to war with Elf weapons
    app = new App(new ElfBlacksmith());
    app.manufactureWeapons();
  }
  
  private void manufactureWeapons() {
    Weapon weapon;
    weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
    LOGGER.info(weapon.toString());
    weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
    LOGGER.info(weapon.toString());
  }
}

运行App程序结果：

适用场景

当遇到如下三种情况时，应使用工厂模式：

1. 一个类不能预测它必须创建的对象的类
2. 一个类希望它的子类指定它创建的对象
3. 类将责任委托给几个助手子类中的一个，并且你希望本地化哪个助手子类是委托的责任

Java中的现实例子

• java.util.Calendar
• java.util.ResourceBundle
• java.text.NumberFormat
• java.nio.charset.Charset
• java.net.URLStreamHandlerFactory
• java.util.EnumSet
• javax.xml.bind.JAXBContext

优缺点

优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口

缺点：
每次增加一个产品时，都需要增加一个具体实现类和修改对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事

写在最后

工厂模式作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂模式，比如设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个通讯接口。

对于简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式，因为使用工厂模式必然要引入一个工厂类，这会增加系统的复杂度，切不可为了设计模式而模式。

下一篇文章我们将在工厂模式的基础上继续延伸介绍抽象工厂模式，难度系统为中级

码字不易，各位看官喜欢的话，请给点个赞️，如果你对接下来的文章有什么建议或者要求可在评论中积极留言，谢谢大家！