1. 简介

工厂模式是简单工厂模式的延伸，符合开闭原则的基础上，还可以在增加新的具体产品对象时不需要对已有系统做任何修改。
定义一个接口或一个抽象的工厂类，让它实现（工厂）来创建哪一个实例对象。

根据每个工厂不同的方法，来产生不同的所需要的对象。

1. 解耦。把对象的创建和使用的过程分开。就是Class A 想调用 Class B，那么A只是调用B的方法，不需要管B的实例化或者不感知B如何实例化，创建的工作交给工厂类。
2. 代码复用。如果创建对象B的过程需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。把创建对象B的代码放到工厂里统一管理。既减少重复代码，也方便以后对B的创建过程的修改和维护
3. 符合迪米特法则和单一职责，使用者只需要知道如何使用以及负责如何用，无须感知创建的逻辑。

缺点：

• 添加新产品会增加具体工厂类和具体产品类，这无疑会增加系统的复杂度，带来更多的开销。。。

2. 代码

2.1 抽象类：Course.java

public abstract class Course{
    public abstract void make();
}

2.2 产品A：JavaCourse.java

public class JavaCourse extends Course {

    @Override
    public void make() {
        System.out.println("制作java课程");
    }
}

2.3 产品B：PythonCourse.java

public class PythonCourse extends Course{

    @Override
    public void make() {
        System.out.println("制作python课程");
    }
}

2.4 工厂抽象类：CourseFactory.java

public abstract class CourseFactory {
    public abstract Course getCourse();
}

2.5 产品A的工厂A：JavaCourseFactory.java

public class JavaCourseFactory extends CourseFactory {
    @Override
    public Course getCourse() {
        return new JavaCourse();
    }
}

2.6 产品B的工厂B：PyCourseFactory.java

public class PyCourseFactory extends CourseFactory {
    @Override
    public Course getCourse() {
        return new PythonCourse();
    }
}

2.7 测试：Test.java

public class Test {
    public static void main(String[] args) {
        JavaCourseFactory javaFactory = new JavaCourseFactory();
        Course javaCourse = javaFactory.getCourse();
        javaCourse.make();
        
        PyCourseFactory pythonFactory = new PyCourseFactory();
        Course pythonCourse = pythonFactory.getCourse();
        pythonCourse.make();
    }
}

运行结果：

制作java课程
制作python课程

3. 总结

BeanFactory就是使用的这个模式，org.springframework.beans.factory.BeanFactory(version:5.0.5)
这里就不进行更多说明了，想知道更多，自己去看源码。

4. 参考链接（无）