在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单工厂模式

简单工厂模式是由一个工厂对象决定产生出哪一类产品类的实例。

实现一个基本的工厂模式

public interface ICourse {
    public void record();
}

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 course");
    }
}

//调用
public static void main(String[] args) {
        ICourse course = new JavaCourse();
        course.record();
    }

如果业务拓展，我们的课程越来越多,那么我们的代码就会显得很笨重。因此，想办法把依赖减弱，把实现细节隐藏起来。

//创建一个课程工厂
public class CourseFactory {

    public ICourse getCourse(String name) {
        switch (name) {
            case "Java":
                return new JavaCourse();
            case "Python":
                return new PythonCourse();
            default:
                throw new RuntimeException("没有该课程");
        }
    }
}

//修改调用方法
public static void main(String[] args) {
        CourseFactory courseFactory = new CourseFactory();
        courseFactory.getCourse("Java").record();
    }

客户端变简单了，但是每次新增课程，都要在CourseFactory中修改逻辑，不符合开闭原则。我们要继续修改，在这里用到了反射。

public class CourseFactory {

    public ICourse getCourse(Class<? extends ICourse> clazz) {
        try {
            if (clazz!= null){
                return clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

public static void main(String[] args) {
        CourseFactory courseFactory = new CourseFactory();
        courseFactory.getCourse(JavaCourse.class).record();
    }

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

课程工厂实现

FactoryProducer 用来提供创建工厂的方法，笔记工厂和课程工厂分别提供笔记和课程。

超级工厂类：

public interface AbstractFactory {

    public ICourse getCourse(String course);

    public INote getNote(String note);

}

课程工厂类：

public class CourseFactory implements AbstractFactory{


    @Override
    public ICourse getCourse(String course) {
        switch (course){
            case "JavaCourse":
                return new JavaCourse();
            default:
                throw new RuntimeException("no such Course");
        }
    }

    @Override
    public INote getNote(String note) {
        return null;
    }

}

笔记工厂类:

public class NoteFactory implements AbstractFactory {
    @Override
    public ICourse getCourse(String course) {
        return null;
    }

    @Override
    public INote getNote(String note) {
        switch (note) {
            case "JavaNote":
                return new JavaNote();
            default:
                throw new RuntimeException("no such Note");
        }
    }
}

课程工厂和笔记工厂都是围绕超级工厂创建的类。

课程接口：

public interface ICourse {

    public void createCourse();

}

课程实现类:

public class JavaCourse implements ICourse{

    @Override
    public void createCourse() {
        System.out.println("JavaCourse");
    }
}

调用过程

public static void main(String[] args) {
        AbstractFactory factory = FactoryProducer.getFactory("Course");
        ICourse course =factory.getCourse("JavaCourse");
        course.createCourse();
    }