从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 

下面模拟使用简单工厂模式实现的需求：

需求：假设现在的我们需要对数据库中的内容进行输出，需要依赖于一个输出的类，但现在有两种方式进行输出，分别是：excel与word;(这里我简单模拟，因此代码会很简单)；

  1. 首先我们先用写一个输出方式的接口,代码如下：

1
2
3
4
public interface Print
{
    public void outPrint();
}

2.然后需要写出它的两个实现类,如下：
excel方式：

1
2
3
4
5
6
7
8
public class ExcelImpl implements Print
{
    @Override
    public void outPrint()
    {
        System.out.println("使用excel进行导出");
    }
}

word方式：

1
2
3
4
5
6
7
8
public class WordImpl implements Print
{
    @Override
    public void outPrint()
    {
        System.out.println("使用word进行导出");
    }
}

3.然后实现一个工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class PrintFactory
{
    /**
     * 用于获取print实例的方法
     * */
    public Print getPrint()
    {
        /**
         * 这里默认返回的是excel方式进行导出
         * */
        return new ExcelImpl();
    }
}

4.进行简单工厂方式的实现：

public class DataOutput

{

    public static void main(String[] args)

    {

        /**

         * 实例化工厂类

         * */

        PrintFactory printFactory = new PrintFactory();

        /**

         * 实例化调用的类，通过构造方法来对DataOutput对象进行初始化

         * */

        DataOutput dataOutput = new DataOutput(printFactory.getPrint());

        dataOutput.output();

    }

     

    private final Print print;

     

    public DataOutput(Print print)

    {

        this.print = print;

    }

     

    /**

     * 模拟导出，这里就是需要调用其他对象中的方法进行实现

     */

    public void output()

    {

        print.outPrint();

    }

}

   


好了，接下来我们只要点击运行就会在控制台出现：使用excel进行导出；

如果由于需求的改变需要使用word来进行导出，很简单，我们只需要修改工厂类中的方法即可，其他都不需要变：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class PrintFactory
{
    /**
     * 用于获取print实例的方法
     * */
    public Print getPrint()
    {
        /**
         * 这里默认返回的是excel方式进行导出
         * */
        // return new ExcelImpl();
        /**
         * 更改为使用word方式进行导出
         * */
        return new WordImpl();
    }
}

到此我们已经实现了一个简单工厂模式，我们能够很明显的感觉到该模式的优势：让对象的调用者与对象创建过程进行分离，当对象调用者需要对象时只需直接向工厂请求即可，
从而避免了对象调用者与对象实现类以硬编码方式进行耦合。就如上面的程序，即使Print接口有很多实现类，我们只需要到工厂类中进行更换实现类的实例化即可，其他不需要

更改，这里也显示了面向接口编程的优势，这样对象的调用者就与接口进行耦合而不是与实现类，与接口耦合的好处就是接口可以有多个实现类，保证了我们可以不去修改接口，

而只是添加或者修改一个实现类即可；

 总结下简单工厂模式：不知道大家有没有发现一个问题就是上面管理实例分配的工厂类中，现在只能每次为其分配一个实例，如果要配置多个实例就需要在工厂类中就行逻辑

判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class PrintFactory
{
    /**
     * 用于获取print实例的方法
     * */
    public Print getPrint(Integer param)
    {
        if(param == 1)
        {
            /**
             * 这里默认返回的是excel方式进行导出
             * */
            return new ExcelImpl();
        }
        else if(param == 2)
        {
            /**
             * 更改为使用word方式进行导出
             * */
            return new WordImpl();
        }
        else
        {
            return null;
        }
         
    }
}

简单工厂模式的有缺点：

优点：该模式的核心就是工厂类，这个类中含有必要的判断逻辑，可以决定在什么时候创建哪个产品类的实例。客户端可以免除直接创建产品对象的责任。

缺点：1.工厂类集中了所有产品创建逻辑，形成一个无所不知的全能类，对于这样的类我们很难进行控制