简单说，工厂和需要生产出来的对象只在生产的方法里有关联，但是每次新增新的实现类，需要修改工厂类的代码

定义课程ICourse接口

public interface ICourse {

    /**
     * 录制视频
     */
    void record();

}

定义ICourse两个实现类

public class JavaCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("录制Java视频");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("录制Python视频");
    }
}

定义工厂类

public class CourseFactory {

    /**
     * 普通工厂
     * 传入名字返回对象
     *
     * @param name 需要创建的类的名字
     * @return 没找到对应对象则返回null
     */
    public static ICourse create(String name) {
        if ("java".equals(name)) {
            return new JavaCourse();
        } else if ("python".equals(name)) {
            return new PythonCourse();
        } else {
            return null;
        }
    }

    /**
     * 进阶工厂2
     *
     * @param clazz 传入类文件
     * @return 对应对象
     */
    public static ICourse create2(Class<? extends ICourse> clazz) {
        if (clazz != null) {
            try {
                return clazz.newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                e.printStackTrace();
                System.out.println("CourseFactory获取对象失败");
            }
        }
        return null;
    }

}

具体使用

    @Test
    public void test2() {
        ICourse java = CourseFactory.create("java");
        assert java != null;
        java.record();
        ICourse python = CourseFactory.create("python");
        assert python != null;
        python.record();
    }

    @Test
    public void test3(){
        ICourse java = CourseFactory.create2(JavaCourse.class);
        java.record();
        ICourse python = CourseFactory.create2(PythonCourse.class);
        python.record();
    }

类关系

image.png

小结

简单工厂顾名思义很简单，看出来了吧，最终对外暴露的也就是一个工厂类，调用create方法就可以获得对应的实现类，缺点就在于新增一个实现类，就需要到工厂类中维护（不符合开闭原则）；

具体使用

jdk中的Calendar.getInstance()方法以及logback的LoggerFactory.getLogger(String name)|(String clazz)，都是简单工厂设计模式。