在面试中通过工厂模式来证明自己的能力

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

**开源地址：https://docs.qq.com/doc/DSmxTbFJ1cmN1R2dB **

10 interface BookFactory { Book createBook(); }

11 public class JavaFactory implements BookFactory{

12 public JavaBook createBook(){

13 //省略其它编写Java书的代码

14 return new JavaBook();

15 }

16 }

17 public class DBFactory implements BookFactory{

18 public DBBook createBook() {

19 //省略其它编写数据库书的代码

20 return new DBBook();

21 }

22 }

在上述代码里，我们提供了“创建”的方法，下面我们给出了“调用”的代码，从第2和第4行的代码中我们能看到，这里外部对象可以通过两种不同的createBook方法分别得到Java和数据库书。

1 BookFactory javaFactory = new JavaFactory ();

2 JavaBook javaBook = javaFactory.createBook();

3 BookFactory dbFactory = new DBFactory ();

4 DBBook dbBook = dbFactory.createBook();

2 简单工厂模式违背了开闭原则

---

大家在通过上文，举例讲清楚工厂模式后，可以立即说出这个结论。具体举例如下。

在上述的案例中，如果遇到新需求，需要再创建C语言的书，首先可以在Book父类下再创建一个CBook子类，随后可以在BookFactory接口下再创建一个新的工厂来创建，代码如下。

1 public class CBook extends Book { //构建一个新的类

2 public CBook(){System.out.println(“Write C Book”);}

3 }

4 public class CFactory implements BookFactory{

5 public CBook createBook() {

6 //省略其它写C语言书的代码

7 return new CBook();

8 }

9 }

对于这个修改需求，我们并没有修改原有的创建Java和数据库书籍相关的代码，而是通过添加新的模块来实现，这种做法很好地符合了“开闭原则”。

开闭原则（Open Closed Principle，也叫OCP）和设计模式无关，它是一种设计架构的原则，其核心思想是，系统（或模块或方法）应当对扩展开放，对修改关闭，比如对于上述案例，遇到扩展了，我们没有修改现有代码，从而可以避免测试不相干的模块。

我们就用简单工厂为例，来看下没采用开闭原则的后果，比如我们还是要创建Java和数据库方面的书，那么是在一个方法里根据参数的不同来返回不同种的类型。

1 public class BookFactory {

2 public Book create(String type) {

3 switch (type) {

4 case “Java”: return new JavaBook();

5 case “DB”:return new DBBook();

6 //要扩展的话，只能加在这里

7 case “C”:return new CBook();

8 default: return null;

9 }

10 }

11 }

如果要加新类型的书，只能是新加一个case，一旦有修改，那么我们得改动第2行的create方法，这样一来，create方法（乃至BookFactory类）对修改就不关闭了。如果大家对此不理解，可以回顾下工厂模式的案例，当时遇到这个需求，我们是通过添加CFactory类来实现的，原来的BookFactory和DBFactory并没有改动（它们对修改关闭了）。

对比一下两者的差别，由于简单工厂模式没遵循开闭原则，那么一旦添加C语言的书籍，那么就影响到其它不相干的Java和DB书籍了（这两部分的case代码也得随之测试），这也是为什么简单工厂模式适用场景比较少的原因。

3 抽象工厂和一般工厂模式的区别

---

抽象工厂是对一般工厂模式的扩展，比如我们在写java和数据库方面的书籍时，需要添加录制讲解视频的方法，也就是说，在Java书和数据库书这两个产品里，我们不仅要包含文稿，还得包含视频。

具体到生产Java书和数据库书的这两个工厂里，我们要生产多类产品，不仅得包括文稿，还得包括代码，此时就可以使用抽象模式，示例代码如下。

1 class Video { //视频的基类

2 public Video(){ }

3 }

4 public class JavaVideo extends Video { 省略定义动作 }

5 public class DBBook extends Video { 省略定义动作 }

在第1行里，我们创建了视频的基类，在第4和第5行里，创建了针对Java和数据库书视频的两个类。

6 abstract class CreateBook{ //抽象工厂

7 public abstract Book createBook();//编写文稿

8 public abstract Book createVideo();//录制视频

9 }

10 //具体创建java书的工厂

11 class CreateJavaBook extends CreateBook{

12 public JavaBook createBook() {省略编写文稿的具体动作}

13 public JavaVideo createVideo() {省略录制视频的具体动作}

14 }

15 //具体创建数据库书的工厂

16 class CreateDBBook extends CreateBook{

17 public DBBook createBook() {省略编写文稿的具体动作}

18 public DBVideo createVideo() {省略录制视频的具体动作}

19 }

在第6行里，我们定义了一个抽象工厂，在其中定义了创建视频和书籍的两个方法，在第11和16行，我们通过继承这个抽象工厂，实现了生产两个具体Java和数据库书籍的工厂。

和一般工厂相比，抽象工厂的顶层类一般是抽象类（也就是抽象工厂名称的来源），但和一般工厂模式相比，没有优劣之分，只看哪种模式更能适应需求。比如要在同一类产品（比如书）里生产多个子产品（比如文稿和视频），那么就可以通过抽象工厂模式，而如果需要生产的产品里只有主部件（比如文稿），而不需要附属产品（比如视频），那么就可以用一般工厂模式。

4 再进一步分析建造者模式和工厂模式的区别

---

建造者模式和工厂模式都是关注于“创建对象”，在面试时，我们一般会问它们的差别。通过工厂模式，我们一般都是创建一个（或一类）产品，而不关心产品的组成部分，建造者模式也是用来创建一个产品，但它不仅创建产品，更专注这个产品的组件和组成过程。

通过下面的代码，我们来看下建造者模式的用法，大家可以对比下建造者和工厂模式的差别。

1 //定义一个待生产的产品，比如带视频讲解的书

2 public class BookwithVideo {

3 //其中包括了稿件和视频两个组件

4 Book PaperBook;

5 Video Video;

6 }

7 //定义一个抽象的建造者

8 public abstract class Builder {

9 public abstract Book createPaperBook();//编写稿件

10 public abstract Video createVideo();//录制视频

11 }

12 //定义一个具体的建造者，用来创建Java书

13 public class JavaBookProduct extends Builder {

14 private BookwithVideo bookWithVideo = new BookwithVideo();

15 //通过这个方法返回组装后的书（稿件加视频）

16 public BookWithVideo getBook(){return bookWithVideo;}

17 //编写稿件

18 public void setPaperBook() {

19 //创造Java文稿，并赋予javaBook对象

20 bookWithVideo.book = javaBook;

21 }

22 //录制视频

23 public void setVideo() {

24 录制Java书的视频，并赋予javaVideo对象

25 bookWithVideo.video = javaVideo;