一、概念
- 工厂方法模式：用来封装对象的创建。工厂方法模式（Factory Method Pattern）通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。这样，关于超类的代码和子类创建对象的代码之间就解耦了。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个接口，用来创建相关或依赖对象的家族，而不需要明确指定具体类。这样，产品创建的过程只会依赖于接口，而不关心具体的实现是什么，从而达到解耦的目的。
- 角色 - 工厂方法模式：
1、抽象工厂（Creator）：定义了一个抽象的工厂方法，让子类实现此方法制造产品。
2、具体工厂（ConcreteCreator）：实现抽象工厂方法，包含具体生产产品的实现代码，返回一个产品的实例。
3、抽象产品（Product）：定义一个抽象的产品，为了工厂中创建产品类型的匹配。
4、具体产品（ConcreteProduct）：实现抽象产品，包含各自产品的特色代码。 - 角色 - 抽象工厂模式：
1、抽象工厂（Creator）：一般是接口或抽象类，定义了一系列的产品家族。
2、具体工厂（ConcreteCreator）：实现抽象工厂方法，包含一系列产品家族的实现代码。
3、抽象产品（Product）：定义一个抽象的产品，为了工厂中创建产品类型的匹配。
4、具体产品（ConcreteProduct）：实现抽象产品，包含各自产品的特色代码。
二、Demo 实现 - 工厂方法模式
TOPIC：我们要定义一个披萨店，并允许个人或机构加盟，而且个人或机构可以根据当地不同的口味生产不同的披萨。
1、抽象工厂 - PizzaStore.java
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
System.out.println(pizza.name);
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
protected abstract Pizza createPizza(String type);
}
这里，我们定义了一个抽象工厂角色，并定义了一个抽象工厂方法。这样产品（Pizza）的实例化过程会交由抽象工厂的子类 —— 具体工厂去创建。
2、抽象产品 - Pizza.java
public abstract class Pizza {
/**
* 披萨的名字
*/
protected String name;
protected void bake() {
System.out.println("烘烤25分钟...");
}
protected void cut() {
System.out.println("把匹萨沿着对角线切开...");
}
protected void box() {
System.out.println("包装用官方标准的盒子...");
}
}
这里，我们定义了一个抽象产品角色，之所以把产品定义成抽象的，有两个原因：一是为了在具体工厂中生产的产品可以用统一的抽象父类来接收；二是为了让加盟商可以任意的扩展自己的产品。这种设计符合我们的设计原则 —— 面向接口（或抽象）编程，不面向实现编程。
3、具体产品
现在有加盟商要加盟我们的商店，他希望能够按照他们的地方特色，自定义他们要出售的披萨...那么，只要扩展 Pizza 类就可以了！
public class CheesePizza extends Pizza {
public CheesePizza() {
name = "这是一个奶酪披萨";
}
@Override
protected void bake() {
System.out.println("烘烤30分钟...");
}
@Override
protected void cut() {
System.out.println("把匹萨按四等分切开...");
}
@Override
protected void box() {
System.out.println("包装用奶酪披萨特制的盒子...");
}
}
public class DurianPizza extends Pizza {
public DurianPizza() {
name = "这是一个榴莲披萨";
}
@Override
protected void bake() {
System.out.println("烘烤45分钟...");
}
@Override
protected void cut() {
System.out.println("把匹萨按三等分切开...");
}
@Override
protected void box() {
System.out.println("包装用榴莲披萨特制的盒子...");
}
}
4、具体工厂 - PizzaFactory.java
public class PizzaFactory extends PizzaStore {
@Override
protected Pizza createPizza(String type) {
switch (type) {
case "cheese":
return new CheesePizza();
case "durian":
return new DurianPizza();
default:
break;
}
return null;
}
}
这里，我们定义了一个具体工厂角色，继承自抽象工厂，产品（Pizza）的具体实例化代码在这里实现。
5、测试
public class Test {
public static void main(String[] args) {
PizzaStore store = new PizzaFactory();
store.orderPizza("cheese");
store.orderPizza("durian");
}
}
三、使用抽象工厂模式重构代码
1、抽象工厂 - AbstractFactory.java
public interface AbstractFactory {
/**
* @Description 奶酪披萨制造接口
*/
Pizza createCheese();
/**
* @Description 榴莲披萨制造接口
*/
Pizza createDurian();
}
这里，我们定义了一个抽象工厂角色，我们用接口定义了一系列的产品家族。
2、具体工厂
public class AFactory implements AbstractFactory {
@Override
public Pizza createCheese() {
System.out.println("A工厂制造的奶酪披萨");
return new CheesePizza();
}
@Override
public Pizza createDurian() {
System.out.println("A工厂制造的榴莲披萨");
return new DurianPizza();
}
}
public class BFactory implements AbstractFactory {
@Override
public Pizza createCheese() {
System.out.println("B工厂制造的奶酪披萨");
return new CheesePizza();
}
@Override
public Pizza createDurian() {
System.out.println("B工厂制造的榴莲披萨");
return new DurianPizza();
}
}
这是两个具体的工厂类，实现了抽象工厂接口，包含了一系列产品家族的实现代码。
3、抽象产品和具体产品
抽象产品和具体产品的代码和工厂方法模式一致，这里就不加赘述了，来看看抽象工厂的使用吧！
4、测试
public class PizzaStore {
private AbstractFactory abstractFactory;
public PizzaStore(AbstractFactory abstractFactory) {
this.abstractFactory = abstractFactory;
}
public void prepare() {
this.abstractFactory.createCheese();
this.abstractFactory.createDurian();
}
}
public class Test {
public static void main(String[] args) {
AbstractFactory abstractFactory = new AFactory();
PizzaStore pizzaStore = new PizzaStore(abstractFactory);
pizzaStore.prepare();
AbstractFactory abstractFactory2 = new BFactory();
PizzaStore pizzaStore2 = new PizzaStore(abstractFactory2);
pizzaStore2.prepare();
}
}
抽象工厂模式在使用时，利用对象组合和多态将不同的工厂实现类注入到代码中。这样，代码只会依赖接口，根本不关心具体实现是什么，以此达到解耦的目的。
演示源代码：https://github.com/JMCuixy/design-patterns/tree/master/src/main/java/com/example/factory
四、总结
- 依赖倒置原则：要依赖抽象，不要依赖具体类 —— 不能让高层组件依赖底层组件，而且，不管是高层还是底层组件，都应该依赖于抽象。想要遵循依赖倒置原则，工厂模式并非是唯一的技巧，但却是最有威力的技巧之一。
- 编写模块的实现依赖于抽象，在运行时传入具体的实现细节， 这就是依赖倒置的工作原理。依赖倒置原则教我们尽量避免使用具体类，而多使用抽象。
- 依赖倒置原则的目的是让程序员脱离底层粘合代码，编写上层业务逻辑代码。这就让上层代码依赖于底层细节的抽象，从而可以重用上层代码。这种模块化和重用方式是双向的：既可以替换不同的细节重用上层代码，也可以替换不同的业务逻辑重用细节的实现。
- 优点：
1、封装变化。将创建对象的代码集中在一个对象或方法中，可以避免代码的重复。
2、面向接口编程。在实例化对象时，向客户隐藏了实例化的细节，用户只需要关心所需产品对应的工厂，无需关心创建细节，甚至无须知道具体产品类的类名。 - 缺点：
1、系统中类的个数会增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销。
2、由于考虑到系统的可扩展性，需要引入抽象层，增加了系统的抽象性和理解难度。 - 工厂方法模式和抽象工厂模式的区别？
1、工厂方法和抽象工厂的任务都是负责实例化对象，但是工厂方法用的方式是继承，而抽象工厂方式用的方法是对象组合。
2、工厂方法注重于：把对象实例化的代码从具体类中解耦出来 —— 通过子类继承实现，或者目前还不知道将来需要实例化哪些具体类时；抽象工厂注重于：当你需要创建产品家族和想让制造的相关产品集中起来时。