简单工厂模式

什么都交给一个工厂类生产，万能工厂，适合于创建的对象比较简单，类型不多的情形

public class CourseFactory {
    public static ICourse getCourse(String courseName){
        switch (courseName) {
            case "java":
                return new JavaCourse();
            case "python":
                return new PythonCourse();
            default:
                return null;
        }
    }

    public static void main(String[] args) {
        ICourse course1 = CourseFactory.getCourse("java");
        course1.study();
        ICourse course2 = CourseFactory.getCourse("python");
        course2.study();
    }
}
public interface ICourse {
    void study();
}
public class JavaCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习java");
    }
}
public class PythonCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("学习Python");
    }
}

使用场景:

1.创建对象需要大量重复代码

2.创建对象的流程不复杂，且创建各个不同产品对象的代码，耦合性不强

工厂方法

其实就是把简单工厂的创建对象的过程从通过方法隔离创建具体实例 抽象到了类层面，将工厂本身进行抽象，具体的工厂实现抽象工厂，每一个实例工厂各司其职，生产不同对象。

适用场景: 创建实例的过程复杂，防止简单工厂过于庞大，不便于维护。不同工厂职责划分明确，实现了低耦合。

适用场景:

1.创建对象有大量重复代码

2.客户端不依赖产品实例的过程

3.创建对象过程相对简单工厂复杂，且存在明显职能划分，如果用简单工厂，就会出现耦合

public interface ICourse {
    public void study();
}

public class JavaCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习java");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习Python");
    }
}

public interface ICoursefaFactory {
    ICourse createCourse();
}

public class JavaCourseFactory implements ICoursefaFactory {
    @Override
    public ICourse createCourse() {
        init();
        return new JavaCourse();
    }

    private void init(){
        //为了避免初始化java类的过程耦合创建python实例的过程
        //如果使用简单工厂就会出现耦合
        System.out.println("初始化专属于java类的数据");
    }
}

public class PythonCourseFactory implements ICoursefaFactory {
    @Override
    public ICourse createCourse() {
        init();
        return new PythonCourse();
    }

    private void init(){
        System.out.println("初始化专属于python类的数据");
    }
}

public class Test {
    public static void main(String[] args) {
        ICoursefaFactory javaFactory = new JavaCourseFactory();
        ICoursefaFactory pythonFactory = new PythonCourseFactory();
        ICourse course1 = javaFactory.createCourse();
        ICourse course2 = pythonFactory.createCourse();
        course1.study();
        course2.study();
    }
}

抽象工厂

抽象工厂是在工厂方法层面，将生产一系列相关产品对象的工厂方法 进行进一步抽象成一类抽象工厂。

每个工厂生产，不同的

与工厂方法的区别是，工厂方法通过不同工厂实例生产不同对象，没有产品族的概念

抽象工厂，通过不同的工厂实例，生产不同组但是产品族相同的对象， 组与组之间存在相同类型的对象。

总结

工厂方法，就是把创建对象的过程交给工厂类管理，使得用户对创建对象的过程透明化，减少了重复代码。简单工厂，工厂方法，抽象工厂 主要是根据具体场景，在抽象的层次上做出的划分。

简单工厂：各个不同对象创建没有很复杂的代码，例如:我有多个Ihandler的实现类，通过前端传入一个枚举type，switch(type) => Ihandler， 具体handler的构造就是普通的注入到工厂或者new，类似这种场景适用简单工厂。

工厂方法: 创建不同类型对象的方法很复杂，如果使用简单工厂方法，会使不相关的代码耦合，而且工厂会变得很重，因此将每一个对象，单独建立一个工厂，职能划分更清楚，耦合低，但是需要的类更多，代码类结构更复杂。

抽象工厂: 抽象工厂，需要满足一定的场景，不同的工厂生产同一个产品族的对象。我认为是工厂方法之上将具有生产相同产品族的工厂，进行了合并抽象。

工厂模式