本文属于系列文章《设计模式》，附上文集链接

工厂模式定义

• 定义一个创建对象的接口，由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类
• 作用：没使用工厂的话，我们要创造对象使用new，工厂方法就是帮我们负责创建需要的对象。
• 工厂模式是创建类模式。

实现

先看一下没用到工厂类的场景，我们需要AProduct和BProduct

//产品类接口
public interface IProduct {
    public void say();
}
// A产品类
public class AProduct implements IProduct {
    @Override
    public void say() {
        System.out.println("我是A产品");
    }
}
//B产品类
public class BProduct implements IProduct {
    @Override
    public void say() {
        System.out.println("我是B产品");
    }
}
//场景类
public class Client {
    public static void main(String[] args) {
        IProduct aProduct = new AProduct();
        aProduct.say();
        IProduct bProduct = new BProduct();
        bProduct.say();
    }
}
结果：
我是A产品
我是B产品

完美运行，但是这个有什么问题呢？试想一下，假设以后改需求，需要在生产产品的时候传入生产批次，怎么传？构造函数或者setter都可以，但是都有一个问题，就是我们在改了产品类的时候，还得改正在使用它的地方，这个耦合其实可以解的，用的就是工厂方法。

// 抽象工厂类
public abstract class AbstractFactory {
    public  abstract <T extends IProduct> T  getProduct(Class<T> clazz) ;
}
// 具体工厂类
public class ConcreteFactory extends AbstractFactory{
    @Override
    public <T extends IProduct> T getProduct(Class<T> clazz) {
        T product = null;
        try {
            product = (T) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
        }
        return product;
    }
}
// 产品类不变
// 场景类
public class Client {
    public static void main(String[] args) {
        ConcreteFactory factory = new ConcreteFactory();
        AProduct aproduct = factory.getProduct(AProduct.class);
        aproduct.say();
        BProduct bProduct = factory.getProduct(BProduct.class);
        bProduct.say();
    }
}
结果：
我是A产品
我是B产品

• 分析下上面的代码，定义了一个抽象工厂类，工厂里面有一个方法，接收参数是继承产品类接口的类的类属性，确保工厂生产出来必定是继承自IProduct的对象。为什么要用泛型？因为你会发现，不用泛型的话，接收的参数不知道该怎么定义，直接用IProduct的class属性的话，在使用ConcreteFactory传参的时候是不能传实现IProduct接口的类的class属性的。
• 然后结果不变，但是可以发现，依赖关系改变了，没改动代码之前，调用者（场景类）依赖于产品类，只要产品类有改动，都有可能对调用者造成影响。而使用工厂模式后，调用者对产品类的依赖变成了对工厂类的依赖，无论产品类如何变化，调用者都不需要关心，只需要工厂类能够正确返回对象即可，实现了解耦。

以上就是工厂模式。