工厂模式（Factory Design Patter）

什么是工厂模式？

定义一：Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses. (定义一个创建对象的接口，但是让子类决定实例化哪个类。工厂方法让类的实例化延迟到了子类）

定义二：When a method returns one of several possible classes that share a common super class. The class is chosen at runtime. (有一个方法，它返回的是拥有共同父类的子类中的一个。这个子类是在运行时被实例化的。

我的理解：工厂方法是一个能动态生产出我们需要的对象的方法，比如有ABCD四个子类，如果用户输入A，工厂方法就产生A对象，用户输入B，工厂就产生B对象，这些对象的生成是动态的，而不是事先在程序里写死了的。

工厂模式举例

代码来自Youtube视频Design Pattern Tutorial 5，链接忘了……

例子描述：

有一个负责生产敌人飞船的工厂，EnemyShip是父类，有UFOEnemyShip、RocketEnemyShip两个子类，用户输入U，则生产UFOEnemyShip，输入R，则生产RocketEnemyShip。

UML类图：



EnemyShip.java

public abstract EnemyShip {

private String name;
private Double amtDamage;

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

public void setAmtDamage(Double amtDamage) {
this.amtDamage = amtDamage;
}

public String getName() {
return name;
}

public Double getAmtDamage() {
return amtDamage;
}

public void followHeroShip() {
System.out.println(getName() + " is following the hero");
}
public void displayEnemyShip() {
System.out.println(getName() + " is on the screen");
}
public void enemyShipShoot() {
System.out.println(getName() + " attack and does " + getAmtDamage());
}

}

UFOEnemyShip.java

public class UFOEnemyShip extends EnemyShip{
public UFOEnemyShip() {
setName("UFO Enemy Ship");
setAmtDamage(20.0);
}
}

RocketEnemyShip.java

public class RocketEnemyShip extends EnemyShip{
public RocketEnemyShip() {
setName("Rocket Enemy Ship");
setAmtDamage(10.0);
}
}

EnemyShipTesting.java
如果不用工厂模式，则如下：在代码中写死了EnemyShip，而不是动态产生。

public class EnemyShipTesting {

public static void main(String[] args) {
EnemyShip ufoShip = new UFOENemyShip();
doStuffEnemy(ufoShip);
}

public static void doStuffEnemy(EnemyShip enemyShip) {
enemyShip.displayEnemyShip();
enemyShip.followHeroShip();
enemyShip.enemyShipShoot();
}
}

如果我们想实现动态，则应该将代码改为：

public class EnemyShipTesting {

public static void main(String[] args) {
EnemyShip theEnemy = null;
Scanner userInput = new Scanner(System.in);
String enemyShipOpt = "";
System.out.println("What type of ship? U/R");
if (userInput.hasNextLine()) {
enemyShipOpt = userInput.nextLine();
}
if (userInput.equals("U")) {
theEnemy = new UFOEnemyShip();
} else if (userInput.equals("R")) {
theEnemy = new RocketEnemyShip();
} else {
System.out.println("please input U/R next time");
}
doStuffEnemy(theEnemy);
}

public static void doStuffEnemy(EnemyShip enemyShip) {
enemyShip.displayEnemyShip();
enemyShip.followHeroShip();
enemyShip.enemyShipShoot();
}
}

但是上面的代码不符合开闭原则，没有对修改close，所以我们再次修改代码为：

1、添加EnemyShipFactory类

EnemyShipFactory.java

public class EnemyShipFactory {
public EnemyShip makeEnemyShip(String shipType) {
if (shipType.equals("U")) {
return new UFOEnemyShip();
} else if (shipType.equals("R")) {
return new RocketEnemyShip();
} else {
return null;
}
}
}

2 、在main中调用工厂方法

public class EnemyShipTesting {

public static void main(String[] args) {
EnemyShipFactory shipFactory = new EnemyShipFactory();
EnemyShip theEnemy = null;
Scanner userInput = new Scanner(System.in);
String enemyShipOpt = "";
System.out.println("What type of ship? U/R");
if (userInput.hasNextLine()) {
enemyShipOpt = userInput.nextLine();
theEnemy = shipFactory.makeEnemyShip(enemyShipOpt);
}
if (theEnemy != null) {
doStuffEnemy(theEnemy);
} else {
System.out.println("please input U/R next time");
}
}

public static void doStuffEnemy(EnemyShip enemyShip) {
enemyShip.displayEnemyShip();
enemyShip.followHeroShip();
enemyShip.enemyShipShoot();
}
}

什么时候使用工厂模式？

1、当你需要动态地创建子类对象的时候，如上例。

2、工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，但是需要慎重地考虑是否要增加一个工厂类进行管理，增加代码复杂度。

3、当需要灵活的、可扩展的框架时，可以考虑工厂模式。

工厂方法模式的优点

1、良好的封装性，代码结构清晰。一个对象创建是有约束条件的，如一个调用者需要一个具体的产品对象，只要知道类名（或约束字串）就可以了，不用知道过程，降低模块间的耦合性。
2、工厂模式的扩展性非常优秀，在增加产品类的情况下，只要适当地修改具体的工厂类，或扩展一个工厂类，就可以拥抱变化。
3、工厂模式时典型的解耦框架。高层模块只需要知道产品的抽象类，不需要管实现，符合迪米特法则，也符合依赖倒置原则，只依赖产品的抽象类，也符合里式替换原则，使用产品子类替换父类。

用工厂方法模式的缺点

可能会增加代码的复杂度。