设计模式之——工厂模式

简单工厂

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于 GOF，23 种设计模式（参考资料：http://en.wikipedia.org/wiki/Design_Patterns#Patterns_by_Type）

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

代码实现：

接口定义：

public interface ICourse {

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

实现接口：

public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制 Java 课程");
    }
}

public class PythonCourse implements ICourse {
    public void record() {
        System.out.println("录制 Python 课程");
    }
}

调用：

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

缺点：业务增加的话，会增加很多不同的实现，工厂类的职责相对过重，不易于扩展过于复杂的产品结构，因此，要把这种依赖减弱，把创建的细节隐藏

 

工厂方法模式

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

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

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

代码实现：

接口定义：

public interface ICourseFactory {
    ICourse create();
}

public interface ICourse {

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

实现接口：

public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制 Java 课程");
    }
}

public class PythonCourse implements ICourse {
    public void record() {
        System.out.println("录制 Python 课程");
    }
}

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

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

测试：

public static void main(String[] args) {
    ICourseFactory factory = new PythonCourseFactory();
    ICourse course = factory.create();
    course.record();

    factory = new JavaCourseFactory();
    course = factory.create();
    course.record();
}

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

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

 

抽象工厂模式

抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类

客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

代码实现：

接口定义：

public interface IVideo {
    void record();
}

public interface INote {
    void edit();
}

/**
* 抽象工厂是用户的主入口
* 在 Spring 中应用得最为广泛的一种设计模式
* 易于扩展
*/
public interface CourseFactory {
    INote createNote();
    IVideo createVideo();
}

拓展类创建

public class JavaVideo implements IVideo {
    public void record() {
        System.out.println("录制 Java 视频");
    }
}

public class JavaNote implements INote {
    public void edit() {
        System.out.println("编写 Java 笔记");
    }
}

具体工厂实现

public class JavaCourseFactory implements CourseFactory {

    public INote createNote() {
        return new JavaNote();
    }

    public IVideo createVideo() {
        return new JavaVideo();
    }
}

调用

public static void main(String[] args) {
    JavaCourseFactory factory = new JavaCourseFactory();
    factory.createNote().edit();
    factory.createVideo().record();
}

缺点：
1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
2、增加了系统的抽象性和理解难度