第 2 章 工厂模式【Factory Pattern】

简单工厂模式（Simple Factory Pattern）

简单工厂模式适用于工厂负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心

接下来直接上代码，以课程为例，java 和python两个课程

/**
 * 定义一个课程ICourse标准接口
 */
public interface ICourse {

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

/**
 * 创建一个实现类JavaCourse
 */
public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制java课程");
    }
}

/**
 * 创建一个实现类PythonCourse
 */
public class PythonCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制python视频课程");
    }
}

/**
 * 创建一个课程工厂生产ICourse课程
 */
public class CourseFactory {

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


/**
 * 测试调用代码
 */
public class Client {
    public static void main(String[] args) {
        CourseFactory factory = new CourseFactory();
        ICourse course = factory.createCourse(JavaCourse.class);
        course.record();
    }
}

注意：简单工厂模式不属于23中设计模式的一种

简单工厂模式在JDK源码也是无处不在，例如Calendar类，Calendar.getInstance()方法

还有大家经常使用的logback，可以看到LoggerFactory的getLogger方法

工厂方法模式（Factory Method Pattern）

工厂方法模式是指定以一个创建对象的接口，让实现这个接口的类去决定实例化哪一个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节，而且加入新的产品符合开闭原则。

直接上代码，先创建一个ICourseFactory接口

public interface ICourseFactory {
    ICourse create();
}


分别创建子工厂javaCourseFactory,pythonCourseFactory

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

public class PythonCourseFactory implements ICourseFactory{
    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

测试代码

public class Client {
    public static void main(String[] args) {
        ICourseFactory javaCourseFactory = new JavaCourseFactory();
        ICourse javaCourse = javaCourseFactory.create();
        javaCourse.record();

        ICourseFactory pythonCourseFactory = new PythonCourseFactory();
        ICourse python = pythonCourseFactory.create();
        python.record();
    }
}

结果：
录制java课程
录制python视频课程

再看一下类图

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

1. 创建对象需要大量重复的代码
2. 客户端（应用层）不依赖与产品实例如何被创建、实现等细节
3. 一个类通过其他子类来指定创建哪个对象

工厂方法的缺点：

1. 类的个数容易过多，增加类的复杂度
2. 增加了系统的抽象性和理解难度

抽象工厂模式（Abastract Factory Pattern）

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

类图

代码实现

//定义INote接口
public interface INote {
    void edit();
}

//定义IVideo接口
interface IVideo {
    void record();
}

//抽象工厂
public abstract class CourseFactory {
    public void init(){
        System.out.println("初始化基础数据");
    }

    protected abstract INote createNote();
    protected abstract IVideo createVideo();

}

//创建java产品族，java视频JavaVideo类：
public class JavaVideo implements IVideo{
    @Override
    public void record() {
        System.out.println("录制java视频");
    }
}

//扩展产品等级Java课堂笔记JavaNote类
public class JavaNote implements INote{
    @Override
    public void edit() {
        System.out.println("编写java笔记");
    }
}

//创建Java产品族的具体工厂JavaCourseFactory
public class JavaCourseFactory extends CourseFactory{
    @Override
    protected INote createNote() {
        super.init();
        return new JavaNote();
    }
	@Override
	 protected IVideo createVideo() {
	     super.init();
	     return new JavaVideo();
	 }
}

//创建python产品族，python视频PythonVideo 类：
public class PythonVideo implements IVideo{
    @Override
    public void record() {
        System.out.println("录制python视频");
    }
}

//扩展产品等级python课堂笔记pythonNote类
public class PythonNote implements INote{
    @Override
    public void edit() {
        System.out.println("编写python笔记");
    }
}

//创建python产品族的具体工厂PythonCourseFactory 
public class PythonCourseFactory extends CourseFactory{
    @Override
    protected INote createNote() {
        super.init();
        return new PythonNote();
    }

    @Override
    protected IVideo createVideo() {
        super.init();
        return new PythonVideo();
    }
}


//代码调用
public class Client {
    public static void main(String[] args) {
        JavaCourseFactory javaCourseFactory = new JavaCourseFactory();
        javaCourseFactory.createNote().edit();
        javaCourseFactory.createVideo().record();
    }
}