1、什么是工厂模式

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

2、工厂模式有哪些，各自的特点是什么

(1)简单工厂模式

- 概念：只需要一个工厂就可以创建产品的工厂模式
- 特点：
(1)创建实例的方法通常为静态方法
(2)简单工厂模式每增加一个产品，就需要增加一个产品类，增加了系统的复杂度，不符合开闭原则
- 结构：
(1)简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。
工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
(2)抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
(3)具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

(2)工厂方法模式

- 概念：是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
简单来说，就是增加了产品类型工厂，同一产品类型（例如永久牌自行车和凤凰牌自行车都是自行车）的产品在同一个工厂中生产。
- 特点：
(1)优点：- 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。- 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。- 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
(2)缺点：- 类的个数容易过多，增加复杂度- 增加了系统的抽象性和理解难度- 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决
- 结构：
(1)抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
(2)具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
(3)抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
(4)具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

(3)抽象工厂模式

- 概念：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级
的产品的模式结构。
- 特点：工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。
- 优点：
(1)可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
(2)当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
(3)抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。
- 缺点：
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。
- 使用条件：
(1)系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
(2)系统一次只可能消费其中某一族产品，即同族的产品一起使用。
- 结构：
(1)抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
(2)具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
(3)抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
(4)具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系
- 个人理解：一个抽象工厂，多个产品牌子工厂，多个产品工厂
- 举例：品牌                  产品
(1)     海尔            电视机、空调、洗衣机
(2)     格力            电视机、空调、洗衣机
我们可以创建3个产品工厂，两个品牌工厂，最终可以生产海尔牌的电视机、空调、洗衣机，格力牌的电视机、空调、洗衣机

3、代码

(1)简单工厂模式代码

产品接口

/*** 产品接口** @author lyq* @version 1.0* @date 2021/7/12 9:43*/
public interface Product {/*** 展示产品*/void show();
}

产品1

/*** 产品类1** @author lyq* @version 1.0* @date 2021/7/12 9:41*/
public class Product1 implements Product{@Overridepublic void show() {System.out.println("电视机");}
}

产品2

/*** 产品类2** @author lyq* @version 1.0* @date 2021/7/12 9:41*/
public class Product2 implements Product {@Overridepublic void show() {System.out.println("洗衣机");}
}

工厂

package factory.simple_factory;/*** 简单工厂模式** @author lyq* @version 1.0* @date 2021/7/12 9:33*/
public class SimpleFactory {public static Product makeProduct(int kind) {switch (kind) {case 0:return new Product1();case 1:return new Product2();default:break;}return null;}public static void main(String[] args) {Product product = SimpleFactory.makeProduct(1);product.show();}}

结果

洗衣机

个人理解

简单工厂模式：适合少量产品的生产。一个产品就需要一个具体的产品类和一个对应的工厂。比如上个例子中的SimpleFactory.class中的makeProduct()方法，每增加一个产品，就需要在switch中增加一个工厂和创建工厂所对应的产品类。

(2)工厂方法模式代码

抽象工厂

/*** 抽象工厂，用来生产产品工厂** @author lyq* @version 1.0* @date 2021/7/12 10:15*/
public interface AbustractFactory {/*** 创建产品* @return Product*/Product newProduct();
}

产品接口

/*** 产品接口，描述产品的特性** @author lyq* @version 1.0* @date 2021/7/12 10:15*/
public interface Product {void show();
}

具体产品工厂

package factory.factory_method;/*** 类型1产品工厂** @author lyq* @version 1.0* @date 2021/7/12 10:28*/
public class ConcreteFactory1 implements AbustractFactory {@Overridepublic Product newProduct() {System.out.print("凤凰牌：");return new ConcreteProduct1();}
}

package factory.factory_method;/*** 类型2产品工厂** @author lyq* @version 1.0* @date 2021/7/12 10:28*/
public class ConcreteFactory2 implements AbustractFactory {@Overridepublic Product newProduct() {System.out.print("永久牌：");return new ConcreteProduct2();}
}

产品

package factory.factory_method;/*** 产品1** @author lyq* @version 1.0* @date 2021/7/12 10:30*/
public class ConcreteProduct1 implements Product {@Overridepublic void show() {System.out.println("自行车");}
}

package factory.factory_method;/*** 产品2** @author lyq* @version 1.0* @date 2021/7/12 10:30*/
public class ConcreteProduct2 implements Product {@Overridepublic void show() {System.out.println("自行车");}
}

测试

package factory.factory_method;/*** TODO** @author lyq* @version 1.0* @date 2021/7/12 11:50*/
public class Test {public static void main(String[] args) {ConcreteFactory1 cf1 = new ConcreteFactory1();cf1.newProduct().show();ConcreteFactory2 cf2 = new ConcreteFactory2();cf2.newProduct().show();}
}

结果

凤凰牌：自行车
永久牌：自行车

个人理解

工厂方法模式，由于他们有一个共同的产品接口，该接口中说明了该类产品的一些特性，所以适合同一类型的产品生产。

(3)抽象工厂模式代码

抽象工厂：包含多个产品种类

package factory.abstract_factory;/*** 抽象工厂，用来生产产品工厂** @author lyq* @version 1.0* @date 2021/7/12 10:15*/
public interface AbustractFactory {/*** 创建产品种类1* @return Product*/Product1 newProduct1();/*** 创建产品种类2* @return Product*/Product2 newProduct2();
}

产品接口

package factory.abstract_factory;/*** 产品接口，描述产品的特性** @author lyq* @version 1.0* @date 2021/7/12 10:15*/
public interface Product1 {void show();
}

package factory.abstract_factory;/*** 产品接口，描述产品的特性** @author lyq* @version 1.0* @date 2021/7/12 10:15*/
public interface Product2 {void show();
}

产品工厂

package factory.abstract_factory;/*** 类型1产品工厂** @author lyq* @version 1.0* @date 2021/7/12 10:28*/
public class ConcreteFactory1 implements AbustractFactory {@Overridepublic Product1 newProduct1() {System.out.print("凤凰牌：");return new ConcreteProduct11();}@Overridepublic Product2 newProduct2() {System.out.print("凤凰牌：");return new ConcreteProduct21();}
}

package factory.abstract_factory;/*** 类型2产品工厂** @author lyq* @version 1.0* @date 2021/7/12 10:28*/
public class ConcreteFactory2 implements AbustractFactory {@Overridepublic Product1 newProduct1() {System.out.print("永久牌：");return new ConcreteProduct12();}@Overridepublic Product2 newProduct2() {System.out.print("永久牌：");return new ConcreteProduct22();}
}

具体产品

package factory.abstract_factory;/*** 产品1** @author lyq* @version 1.0* @date 2021/7/12 10:30*/
public class ConcreteProduct11 implements Product1 {@Overridepublic void show() {System.out.println("自行车");}
}

package factory.abstract_factory;/*** 产品1** @author lyq* @version 1.0* @date 2021/7/12 10:30*/
public class ConcreteProduct12 implements Product1 {@Overridepublic void show() {System.out.println("自行车");}
}

package factory.abstract_factory;/*** 产品2** @author lyq* @version 1.0* @date 2021/7/12 10:30*/
public class ConcreteProduct21 implements Product2 {@Overridepublic void show() {System.out.println("电视机");}
}

package factory.abstract_factory;/*** 产品2** @author lyq* @version 1.0* @date 2021/7/12 10:30*/
public class ConcreteProduct22 implements Product2 {@Overridepublic void show() {System.out.println("电视机");}
}

测试

package factory.abstract_factory;/*** TODO** @author lyq* @version 1.0* @date 2021/7/12 11:50*/
public class Test {public static void main(String[] args) {ConcreteFactory1 cf1 = new ConcreteFactory1();cf1.newProduct1().show();cf1.newProduct2().show();ConcreteFactory2 cf2 = new ConcreteFactory2();cf2.newProduct1().show();cf2.newProduct2().show();}
}

结果

凤凰牌：自行车
凤凰牌：电视机
永久牌：自行车
永久牌：电视机

个人理解

这里创建了：
两个品牌（产品工厂）：凤凰牌、永久牌
两个产品种类（具体产品）：电视机、自行车，由于要分别生产凤凰牌和永久牌的电视机和自行车，所以要创建四个产品类。

参考了：c语言中文网 http://c.biancheng.net/view/8385.html

设计模式-工厂模式(详细)相关推荐

1. Java设计模式-工厂模式（3）抽象工厂模式

   在Java设计模式-工厂模式(2)工厂方法模式 我们知道了工厂方法模式解决了简单工厂模式中的缺陷,做到了满足开闭原则,但是时代是进步的,进而又产生新的问题,工厂难道只能生产一种东西吗.我们所见到的工厂 ...

2. Java设计模式-工厂模式（2）工厂方法模式

   在Java设计模式-工厂模式(1)简单工厂模式 中我们介绍了简单工厂模式,提到了简单工厂模式违背了开闭原则,而"工厂方法模式"是对简单工厂模式的进一步抽象化,其好处是可以使系统在不 ...

3. Java设计模式-工厂模式（1）简单工厂模式

   Java设计模式-工厂模式(1)简单工厂模式 一.前言 1)例子 2)类图关系 3)代码实现 二.简单工厂模式 2.1.概述: 2.2.类图关系: 2.3.代码修改: 2.4.优缺点 2.5.扩展-简 ...

4. 设计模式---工厂模式

   设计模式---工厂模式 工厂方法模式 概述:工厂方法模式中抽象工厂负责定义创建对象的接口,具体创建工作由继承抽象工厂的具体类实现. 优点:客户端不需要再负责对象的创建,从而明确了各个类的职责,如果有新 ...

5. java设计模式工厂模式_Java中的工厂设计模式

   java设计模式工厂模式 Welcome to the Factory Design Pattern in Java tutorial. Factory Pattern is one of the C ...

6. java设计模式工厂模式_Java中的复合设计模式

   java设计模式工厂模式 Composite pattern is one of the Structural design pattern. Composite design pattern is ...

7. java设计模式工厂模式_Java中的桥梁设计模式

   java设计模式工厂模式 Today we will look into Bridge Design Pattern in java. When we have interface hierarchi ...

8. java设计模式工厂模式_Java中的外观设计模式

   java设计模式工厂模式 Facade Design Pattern is one of the Structural design patterns (such as Adapter pattern ...

9. 设计模式-工厂模式（学习）

   设计模式-工厂模式(学习) 在程序的世界里,就像射雕英雄传一样,我们的技能就像是武功一样,我们只有不断去学习练习才能有机会像郭靖一样成为"天下第一". 我认为技能和武功是很类似的, ...

最新文章

1. RabbitMQ 入门系列（9）— Python 的 pika 库常用函数及参数说明
2. 如何在R中正确使用列表？
3. AngularJS快速上手
4. Eclipse Java注释模板设置详解
5. Java——List集合特有的功能
6. 第5 章持久化类(Persistent Classes)
7. A*算法（一）算法导言
8. IE下angularJS页面跳转的bug
9. 【MySQL】明明加了索引，为何不生效？
10. C++基础知识（三）C++的输入和输出及操纵符
11. JUCE框架教程（5）——Plugin项目构造基础
12. （十九）论文阅读 | 目标检测之SNIP
13. 数组合并对象里相同属性值
14. 搞懂它，带你学会高效配置交换机！
15. APIO2014 连珠线
16. 蝴蝶影视服务器响应异常,elasticsearch的服务器响应异常及解决策略（转）
17. python数据结构之单链表
18. 基于HBuilder 开发 项目之微信支付
19. HDUOJ 1114 Piggy-Bank
20. c++ 用 eigen与opencv计算两个向量的夹角，两个向量之间的夹角，向量的朝向

热门文章

1. 数据平台专题会议第3天亮点
2. GraphPad Prism 8 可做哪些图？GraphPad Prism快速入门
3. python3.6安装库_python3.6怎么安装库
4. nodejs 安装及环境配置
5. 【096】求等差数列前N项和？
6. python图像处理（十）——图像仿射变换、图像透视变换和图像校正
7. 面试总结：移动web设计与开发
8. flowable支持集群数据库
9. ComSec作业一：抄书题
10. MySQL基础语句小结