设计模式之工厂方法模式

定义

       工厂方法模式（FACTORY METHOD）是一种常用的类创建型设计模式,此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品

优点：

1. 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
2. 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
3. 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

1. 类的个数容易过多，增加复杂度
2. 增加了系统的抽象性和理解难度
3. 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景：

• 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

模式的结构与实现

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

1. 模式的结构
工厂方法模式的主要角色如下。

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct()
  来创建产品。
• 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

其结构图如图 :

2. 模式的实现
相关代码如下：

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af;
            af = (AbstractFactory) ReadXML1.getObject();
            a = af.newProduct();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}

//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}

//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}

//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }

}
程序运行结果如下：

具体工厂1生成–>具体产品1…

具体产品1显示…

如果将 XML 配置文件中的 ConcreteFactory1 改为 ConcreteFactory2，则程序运行结果如下：

具体工厂2生成–>具体产品2…

具体产品2显示…

实例讲解

比如说我现在有这么个需求，就是我要对面粉进行加工，从而得到馒头、挂面

/**
 * 首先无论是做馒头还是挂面，他们都有一个加工方法，可以抽象出来
 * Machine：机器
 */
public interface MachineApi {
        //process：加工      material:材料
    public void process(String material);
    
}

然后我需要拿到具体产品

/**
 * 馒头机器
 * steamed bun : 馒头
 */
public class SteamedBunMachine implements MachineApi {
    @Override
    public void process(String material) {
        System.out.println("我把" + material + "加工成了馒头");
    }
}

/**
 * 面条机器
 * noodle : 面条
 */
public class BoodleMachine implements MachineApi {
    @Override
    public void process(String material) {
        System.out.println("我把" + material + "加工成了面条");
    }
}

这个时候我需要一个 抽象工厂角色

public abstract class Factory{
    /**
     * 让子类（具体工厂）来实例化具体对象（机器）
     */
    public abstract MachineApi newMachine();
    
    /**
     * 加工材料
     */
    public void process(String material){
        MachineApi machine = newMachine();
        machine.process(material);
    }
    
}

然后我需要两家工厂，分别帮我生成馒头和面条

//馒头工厂
public class SteamedBunFactory extends Factory{
    //馒头工厂，只需要提供馒头机器就行
    @Override
    public MachineApi newMachine() {
        return new SteamedBunMachine();
    }
}

//面条工厂
public class NoodleFactory extends Factory{
    //面条工厂，只需要提供面条机器就行
    @Override
    public MachineApi newMachine() {
        return new BoodleMachine();
    }
}

最后我作为老板，只需要操作工厂就可以进行生成

SteamedBunFactory mSteamedBunFactory  = new SteamedBunFactory ();
mSteamedBunFactory.process("面粉");//我把面粉加工成了馒头