工厂模式是创建性模式，总共分为三种：简单工厂模式，工厂方法模式，抽象工厂模式

什么是工厂模式？

定义一个用户创建对象的借口，让子类决定实例化哪一个类

为什么要用工厂模式？

需要生成复杂对象的地方，都可以使用工厂方法模式。用new就能创建的对象不需要使用工厂模式，因为使用工厂模式就要增加一个工厂类，增加了系统复杂度。

• 降低了对象之间的耦合度，代码结构清晰，对调用者隐藏了产品的生产过程，生产过程改变后，调用者不用做什么改变，易于修改。
• 易于拓展，要增加工厂和产品都非常方便，直接实现接口，不用修改之前的代码。

具体代码实现

模式1
定义一个抽象产品

public abstract class Product {
    /**
     * 产品类的抽象方法，由具体的产品类来实现
     */
    public abstract void mecthod();

}

具体的产品实现

public class ProductA extends Product{
    @Override
    public void mecthod() {
        System.out.println("产品A");
    }
}
public class ProductB extends Product{
    @Override
    public void mecthod() {
        System.out.println("产品B");
    }
}

定义抽象的工厂

public abstract class Factory {
    /**
     *
     * @param cls 产品对象类型
     * @param <T> 具体的产品类型
     * @return
     */
    public abstract Product createProduct();

}

具体产品的工厂实现

public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

实际调用实现

Factory factory = new ConcreteFactory();
Product product = factory.createProduct();
product.method();

这样就可以生产出一个产品ProductA。
如果想生产出产品ProductB的话，在createProduct里修改返回ProductB就行了

public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

模式2
通过反射来了解到底要生产哪个产品

public abstract class Factory {
    /**
     *
     * @param cls 产品对象类型
     * @param <T> 具体的产品类型
     * @return
     */
    public abstract <T extends Product> T createProduct(Class<T> cls);

}

public class ConcreateFractory extends Factory {
    @Override
    public <T extends Product> T createProduct(Class<T> cls) {

        Product product = null;

        try {
            product = (Product) Class.forName(cls.getName()).newInstance();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }


        return (T) product;
    }
}

Factory factory = new ConcreateFractory();
Product product = factory.createProduct(ProductA.class);
product.mecthod();

这样的话在调用的时候传入什么产品就生产出什么产品
模式3
也可以为每个产品都创建一个具体的工厂类，例如：

public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

这样就是要生产哪个就调用哪个工厂
静态工厂模式
当确定工厂类只有一个的时候 可以通过静态方法的形式创建对应的产品

public class Factory{
    public static Product createProduct(){
        return new ProductA();
        //return new ProductB();
    }
}

以上就是对与工厂模式的解释 ，整体来说工厂模式的缺点应该就是会让系统结构复杂化了，如果是非常简单的结构就不需要使用这种模式了。