一、工厂模式是创建型模式

 

二、简单工厂模式

1.简单工厂模式是指由一个工厂对象决定创建出哪一种产品类的实例，不属于GOF23中设计模式。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心

2.简单工厂模式代码示例：

 1 public interface ICourse {
 2     public void record();
 3 }
 4 
 5 public class JavaCourse implements ICourse {
 6     @Override
 7     public void record() {
 8         System.out.println("录制java课程");
 9     }
10 }
11 
12 public class CourseFactory {
13 
14     public static ICourse create(Class<? extends ICourse> clazz){
15         ICourse iCourse = null;
16         try {
17             iCourse = clazz.newInstance();
18         }catch (Exception e){
19             e.printStackTrace();
20         }
21         return iCourse;
22     }
23 }
24 
25 public class SimpleFactoryTest {
26     public static void main(String[] args) {
27         ICourse iCourse = CourseFactory.create(JavaCourse.class);
28         iCourse.record();
29     }
30 }
示例1

 3.简单工厂的缺点：工厂类的职责相对过重，不易于扩展过于复杂的产品结构

 

三、工厂方法模式

1.工厂方法模式是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行

2.在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节，而且加入新的产品符合开闭原则

3.工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个产品的创建逻辑有区别的话，工厂的职责会变得越来越多，有点像万能工厂，并不便于维护。根据单一职责原则我们将职能继续拆分，专人干专事，对工厂本身也做一个抽象

4.工厂方法模式示例：

public interface ICourseFactory {
    public ICourse create();
}

public class JavaCourseFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}

public class FactoryMethodTest {
    public static void main(String[] args) {
        ICourseFactory factory = new JavaCourseFactory();
        factory.create().record();
    }
}
示例2

5.工厂方法适用于以下场景：

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

　　B.客户端(应用层)不依赖于产品类实例如何被创建、实现等细节

　　C.一个类通过其子类来指定创建哪个对象

6.工厂方法的缺点：

　　A.类的个数容易过多，增加复杂度

　　B.增加了系统的抽象性和理解难度

 

四、抽象工厂模式

1.抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。客户端(应用层)不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

2.产品族和产品等级结构

 

 

 3.抽象工厂模式代码示例：

 1 public interface IVideo {
 2     void record();
 3 }
 4 
 5 public interface INote {
 6     void edit();
 7 }
 8 
 9 public abstract class CourseFactory {
10     public void init(){
11         System.out.println("初始化基础数据");
12     }
13 
14     protected abstract INote createNote();
15 
16     protected abstract IVideo createVideo();
17 }
18 
19 public class JavaVideo implements IVideo {
20     @Override
21     public void record() {
22         System.out.println("录制java视频");
23     }
24 }
25 
26 public class JavaNote implements INote {
27     @Override
28     public void edit() {
29         System.out.println("编写java笔记");
30     }
31 }
32 
33 public class JavaCourseFactory extends CourseFactory {
34     @Override
35     protected INote createNote() {
36         super.init();
37         return new JavaNote();
38     }
39 
40     @Override
41     protected IVideo createVideo() {
42         super.init();
43         return new JavaVideo();
44     }
45 }
46 
47 public class AbstractFactoryTest {
48     public static void main(String[] args) {
49         JavaCourseFactory javaCourseFactory = new JavaCourseFactory();
50         javaCourseFactory.createNote().edit();
51         javaCourseFactory.createVideo().record();
52     }
53 }
示例3

 

4.抽象工厂缺点：

　　A.规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口

　　B.增加了系统的抽象性和理解难度