我们知道Java里边共有23种设计模式而工厂模式就有三种，它们分别是简单工厂模式(并不在23中模式之中)，工厂方法模式以及抽象工厂模式，其中我们通常所说的工厂模式指的是工厂方法模式,他们都属于创建型设计模式。
简单工厂模式
定义
定义一个工厂类，根据传入不同的工厂参数创建不同的对象。
适用场景
（1）工厂类负责创建较少的对象。
（2）客户端只需要传入工厂类参数，对创建对象的细节不须关心。
优点
只需要传入一个正确的参数，就可以获得你所需要的对象，无需关心其创建细节
缺点
增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则
实例
创建一个可以录制课程的不同课程，可以创建Java课程、Python课程，每个课程都会有一个record()方法用于录制课程，不看代码先考虑一下如何通过该模式设计完成此功能。
由题可知Java课程、Python课程都属于一种课程，所以首先可以定义一个接口或者抽象类，作为这两个课程的公共父类，只是习惯定义成接口，而且接口支持多实现方便以后扩展，并在其中声明一个公共的record方法。
public interface ICourse{
void record();
}
下面就是编写具体的课程，每个课程都实现ICourse 接口
Java课程
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("java 录制课程");
}
}
Python课程
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("python 录制课程");
}
}
创建具体的工厂类
public class CourseFactory {
public ICourse create(Class<? extends ICourse> clazz){
try {
//反射 生成对象实例
return clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
在这个工厂类中传入不同的Class对象可以创建不同的课程对象，返回结果为ICourse 类型，这就是简单工厂模式核心所在。
客户端使用
public class CourseFactoryTest {
public static void main(String[] args) {
CourseFactory courseFactory = new CourseFactory();
ICourse iCourse = courseFactory.create(PythonCourse.class);
iCourse.record();
}
}
工厂方法模式
定义:
定义一个创建对象的接口(抽象工厂)，让实现这个接口的类(具体工厂)来决定实例化哪个类，工厂方法让类的实例化推迟到子类(具体工厂)中进行。
适用场景:
(1) 创建对象需要大量重复的代码
(2) 客户端不依赖于产品类实例如何被创建、实现等细节
(3) 一个类通过其子类来指定创建哪个对象
优点:
(1) 用户只需关心所需产品对应的工厂，无需关心创建细节
(2) 加入新产品符合开闭原则，提高系统可扩展性
缺点:
(1) 类的个数容易过多，增加代码结构的复杂度
(2) 增加了系统的抽象性和理解难度
实例:
由题可知Java课程、Python课程都属于一种课程，所以首先可以定义一个接口或者抽象类，作为这两个课程的公共父类，只是习惯定义成接口，而且接口支持多实现方便以后扩展，并在其中声明一个公共的record方法。
public interface ICourse{
void record();
}
下面就是编写具体的课程，每个课程都实现ICourse 接口
Java课程
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("java 录制课程");
}
}
Python课程
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("python 录制课程");
}
}
抽象工厂
public interface ICourseFactory {
ICourse create();
}
Java课程工厂(具体工厂)
public class JavaCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new JavaCourse();
}
}
Python课程工厂(具体工厂)
public class PythonCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
return new PythonCourse();
}
}
每个对象的创建都有一个具体的工厂类，同时具体的工厂类可以进行额外的扩展,返回结果为ICourseFactory (抽象)类型，这就是工厂方法模式核心所在。
客户端使用
public class ICourseFactoryTest {
public static void main(String[] args) {
ICourseFactory courseFactory = new JavaCourseFactory();
ICourse course = courseFactory.create();
course.record();
}
}
抽象工厂模式
定义:
是指提供一个创建一系列相关或相互依赖对象的接口(抽象工厂)，无须指定他们具体的类(在抽象工厂模式中，每一个具体工厂都提供了多个方法用于创建不同类型的对象)。
适用场景:
(1) 客户端不依赖于产品类实例如何被创建、实现等细节。
(2) 同一产品族一起使用创建对象需要大量重复的代码。
(3) 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
优点:
(1) 具体产品在应用层代码隔离，无须关心创建细节。
(2) 将一个系列的产品族统一到一起创建。
缺点:
(1) 产品族中扩展新的产品困难，需要修改抽象工厂的接口。
(2) 增加了系统的抽象性和理解难度。
实例:
由题可知Java课程、Python课程都属于一种课程，所以首先可以定义一个接口或者抽象类，作为这两个课程的公共父类，只是习惯定义成接口，而且接口支持多实现方便以后扩展，并在其中声明一个公共的record方法。
public interface ICourse{
void record();
}
下面就是编写具体的课程，每个课程都实现ICourse 接口
Java课程
public class JavaCourse implements ICourse {
@Override
public void record() {
System.out.println("java 录制课程");
}
}
Python课程
public class PythonCourse implements ICourse {
@Override
public void record() {
System.out.println("python 录制课程");
}
}
由题可知Java课程、Python课程都属于一种课程，所以首先可以定义一个接口或者抽象类，作为这两个课程的公共父类，只是习惯定义成接口，而且接口支持多实现方便以后扩展，并在其中声明一个公共的edit方法。
public interface INote {
void edit();
}
下面就是编写具体的课程，每个课程都实现INote 接口
Java课程
public class JavaNote implements INote {
@Override
public void edit() {
System.out.println("java 课程笔记");
}
}
Python课程
public class PythonNote implements INote {
@Override
public void edit() {
System.out.println("python 课程笔记");
}
}
抽象工厂
public abstract class AbstractCourseFactory {
public void init() {
System.out.println("初始化数据");
}
public abstract ICourse course();
public abstract INote note();
}
java课程工厂
public class JavaCourseFactory extends AbstractCourseFactory {
@Override
public ICourse course() {
super.init();
return new JavaCourse();
}
@Override
public INote note() {
super.init();
return new JavaNote();
}
}
python课程工厂
public class PythonCourseFactory extends AbstractCourseFactory {
@Override
public ICourse course() {
super.init();
return new PythonCourse();
}
@Override
public INote note() {
super.init();
return new PythonNote();
}
}
抽象工厂模式是工厂方法模式的近一步深化，这个模式中的工厂类不但可以创建一个对象，而且可以创建一组对象，这就是抽象工厂模式核心所在。
客户端使用
public class AbstractCourseFactoryTest {
public static void main(String[] args){
AbstractCourseFactory courseFactory = new PythonCourseFactory();
ICourse course = courseFactory.course();
INote note = courseFactory.node();
}
}
