结合实例分析简单工厂模式&工厂方法模式&抽象工厂模式的区别

　　之前写过一篇关于工厂模式（Factory Pattern）的随笔，里面分析了简单工厂模式，但对于工厂方法和抽象工厂的分析较为简略。这里重新分析分析三者的区别，工厂模式是java设计模式中比较简单的一个设计模式，但很多地方都用到了工厂模式，（如解析xml中，jdbc连接数据库等）利用好工厂模式对程序的设计很有用处。工厂模式在一些设计模式的书中分为简单工厂模式，工厂方法模式和抽象工厂模式三类。也有把工厂方法模式划分到抽象工厂模式的，认为工厂方法是抽象工厂模式的特例的一种，就是只有一个要实现的产品接口。下面结合例子分析三者的区别。

　　首先是简单工厂模式，这里以工厂生产产品为例。

产品类的共同接口

1 package factory;
2 /**
3  *
4  * @author CIACs
5  *
6  */
7 public interface Product {
8     //声明类所需继承的共同接口，也可以是抽象类
9 }

产品类A

 1 package factory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class ProductA implements Product {
 8     public ProductA() {
 9         System.out.println("ProductA");
10     }
11 }

产品类B

 1 package factory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class ProductB implements Product {
 8     public ProductB() {
 9         System.out.println("ProductB");
10     }
11 }

工厂类

 1 package factory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class Factory {
 8     //可以在工厂类中添加任何你所需要的逻辑
 9     public static Product create(String str)
10     {
11         //生成ProductA
12         if(str.equalsIgnoreCase("ProductA"))
13         {
14             return new ProductA();
15         }
16         else
17             //生成ProductB
18             if(str.equalsIgnoreCase("ProductB"))
19             {
20                 return new ProductB();
21             }
22         return null;
23     }
24
25 }

客户端

 1 package factory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9         //调用Factory的静态方法生成所要的类
10         Factory.create("productA");
11         Factory.create("ProductB");
12     }
13 }

控制台输出结果：

　　简单工厂模式实现了生成产品类的代码跟客户端代码分离，在工厂类中你可以添加所需的生成产品的逻辑代码，但是问题来了，优秀的java代码是符合“开放-封闭”原则的，也就是说对扩展开发，对修改关闭，如果你要加一个产品类C，你就要修改工厂类里面的生成产品的代码，在这里你就要增加if-else判断。对于这个问题，我们的工厂方法模式就可以解决这个问题。

　　接下来是工厂方法模式

产品类中增加了ProductC（其他产品类的代码是可以重用上面的，只要把包名更改了就行）。

 1 package factoryMehtod;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7
 8 public class ProductC implements Product {
 9     public ProductC() {
10         System.out.println("productC");
11     }
12 }

声明工厂接口

 1 package factoryMehtod;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public interface Factory {
 8     //声明产生产品类的方法
 9     public Product createProduct();
10 }

产生ProductA的FactoryA

 1 package factoryMehtod;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class FactoryA implements Factory {
 8     //实现工厂类的方法生成产品类A
 9     public Product createProduct()
10     {
11         return new ProductA();
12     }
13
14 }

产生ProductB的FactoryB

 1 package factoryMehtod;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class FactoryB implements Factory {
 8     //实现工厂类的方法生成产品类B
 9     public Product createProduct()
10     {
11         return new ProductB();
12     }
13 }

产生ProductC的FactoryC

 1 package factoryMehtod;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class FactoryC implements Factory {
 8     //实现工厂类的方法生成产品类C
 9     public Product createProduct()
10     {
11         return new ProductC();
12     }
13 }

客户端

 1 package factoryMehtod;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9         Factory factory;
10         factory = new FactoryA();
11         factory.createProduct();
12         factory = new FactoryB();
13         factory.createProduct();
14         factory = new FactoryC();
15         factory.createProduct();
16     }
17 }

控制台输出结果：

　　工厂方法模式中我们把生成产品类的时间延迟，就是通过对应的工厂类来生成对应的产品类，在这里我们就可以实现“开发-封闭”原则，无论加多少产品类，我们都不用修改原来类中的代码，而是通过增加工厂类来实现。但是这还是有缺点的，如果产品类过多，我们就要生成很多的工厂类。假如我们要实现的产品接口不止一个，也就是有多个产品接口，不同产品接口有对应的产品族。什么是产品族呢？简单的理解就是，不同牌子产的车里面会有跑车类型，家庭类型，商用类型等的车，不同牌子的车的跑车类型的车可以组成一个产品族。对于这种情况我们可以采用抽象工厂模式。

　　 最后是抽象工厂模式，在这里我们为不同产品附加上对应的礼物，就是说ProductA中会有GiftA。

增加的Gift接口

1 package abstractFactory;
2 /**
3  *
4  * @author CIACs
5  *
6  */
7 public interface Gift {
8     //声明产品赠品的接口，当然也可以是抽象类，同样为了简单就不声明方法了
9 }

GiftA类

 1 package abstractFactory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class GiftA implements Gift {
 8     public GiftA()
 9     {
10         System.out.println("GiftA");
11     }
12 }

GiftB类

 1 package abstractFactory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class GiftB implements Gift {
 8     public GiftB()
 9     {
10         System.out.println("GiftB");
11     }
12 }

Factory接口

 1 package abstractFactory;
 2 /**
 3  *
 4  * @author CIACs
 5  *声明Product类工厂和Gift类工厂的工同工厂接口
 6  */
 7 public interface Factory {
 8     public Product createProduct();
 9     public Gift createGift();
10
11 }

生成ProductA和GiftA的FactoryA

 1 package abstractFactory;
 2 /**
 3  *
 4  * @author CIACs
 5  *FactoryA可以生成ProductA和GiftA
 6  */
 7 public class FactoryA implements Factory {
 8     @Override
 9     public Product createProduct()
10     {
11         return new ProductA();
12     }
13     @Override
14     public Gift createGift()
15     {
16         return new GiftA();
17     }
18 }

生成ProductB和GiftB的FactoryB

 1 package abstractFactory;
 2 /**
 3  *
 4  * @author CIACs
 5  *FactoryB可以生成ProductB和GiftB
 6  */
 7 public class FactoryB implements Factory {
 8     @Override
 9     public Product createProduct() {
10         return new ProductB();
11     }
12     @Override
13     public Gift createGift() {
14         return new GiftB();
15     }
16
17 }

客户端

 1 package abstractFactory;
 2 /**
 3  *
 4  * @author CIACs
 5  *
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9         Factory factory;
10         factory = new FactoryA();
11         factory.createProduct();
12         factory.createGift();
13         factory = new FactoryB();
14         factory.createProduct();
15         factory.createGift();
16     }
17 }

控制台输出结果：

　　抽象工厂模式中我们可以定义实现不止一个接口，一个工厂也可以生成不止一个产品类，抽象工厂模式较好的实现了“开放-封闭”原则，是三个模式中较为抽象，并具一般性的模式。我们在使用中要注意使用抽象工厂模式的条件。

时间： 2024-10-10 06:32:39

结合实例分析简单工厂模式&工厂方法模式&抽象工厂模式的区别的相关文章

简单工厂、工厂方法、抽象工厂、策略模式、策略与工厂的区别

结合简单示例和UML图,讲解工厂模式简单原理. 一.引子 话说十年前,有一个爆发户,他家有三辆汽车(Benz(奔驰).Bmw(宝马).Audi(奥迪)),还雇了司机为他开车.不过,爆发户坐车时总是这样:上Benz车后跟司机说"开奔驰车!",坐上Bmw后他说"开宝马车!",坐上 Audi后他说"开奥迪车!".你一定说:这人有病!直接说开车不就行了?!而当把这个爆发户的行为放到我们程序语言中来,我们发现C语言一直是通过这种方式来坐车的!幸运的是这种有

Java工厂模式（简单工厂、工厂方法、抽象工厂）

工厂模式:主要用来实例化有共同接口的类,工厂模式可以动态决定应该实例化那一个类.工厂模式的形态工厂模式主要用一下几种形态:1:简单工厂(Simple Factory).2:工厂方法(Factory Method).3:抽象工厂(Abstract Factory). 简单工厂(Simple Factory)又叫静态工厂,是工厂模式三中状态中结构最为简单的.主要有一个静态方法,用来接受参数,并根据参数来决定返回实现同一接口的不同类的实例.我们来看一个具体的例子:假设一家工厂,几生产洗衣机,有生产冰箱

总结工厂模式---简单工厂、工厂方法、抽象工厂

简单工厂 首先,我们先看一个简单工厂的例子: #coding=utf-8 class Mercedes(object): """梅赛德斯 """ def __repr__(self): return "Mercedes-Benz" class BMW(object): """宝马 """ def __repr__(self): return "BMW&quo

设计模式(Python)-简单工厂，工厂方法和抽象工厂模式

本系列文章是希望将软件项目中最常见的设计模式用通俗易懂的语言来讲解清楚,并通过Python来实现,每个设计模式都是围绕如下三个问题: 为什么?即为什么要使用这个设计模式,在使用这个模式之前存在什么样的问题? 是什么?通过Python语言来去实现这个设计模式,用于解决为什么中提到的问题. 怎么用?理解了为什么我们也就基本了解了什么情况下使用这个模式,不过在这里还是会细化使用场景,阐述模式的局限和优缺点. 这次的主角是简单工厂,工厂方法和抽象工厂模式,由于这几个模式联系紧密,有一定的相似性,所以放在

工厂模式总结（简单工厂，工厂方法，抽象工厂）

工厂模式属于创建型模式,大致可以分为三类,简单工厂模式.工厂方法模式.抽象工厂模式. 通过两个例子讲解这三种工厂模式 示例一 简单工厂模式 首先介绍简单工厂模式,它的主要特点是需要在工厂类中做判断,从而创造相应的产品.当增加新的产品时,就需要修改工厂类.有点抽象,举个例子就明白了.有一家生产处理器核的厂家,它只有一个工厂,能够生产两种型号的处理器核.客户需要什么样的处理器核,一定要显示地告诉生产工厂.下面给出一种实现方案. 1 enum CTYPE {COREA, COREB}; 2 class

设计模式之工厂模式(简单工厂，工厂方法，抽象工厂)

设计模式6大原则:1.开闭原则:对拓展开放,对修改关闭2.单一职责原则:一个类只复杂一项职责3.里氏原则:子类可以扩展父类的功能,但不改变父类原有的功能4.依赖倒置原则:面向接口编程5.接口隔离原则:设计接口功能尽量细粒度,最小功能单元6.迪米特法则:降低耦合度(局部变量中,不要引入新的类) 这里对工厂模式做一个学习记录 这里用简单计算器来举例. 很简单,我们需要3个输入: a1 代表第一个数字 a2 代表第二数字 operator 代表运算符 这三个参数输入后得到一个输出result 1.平时

设计模式系列---简单工厂、工厂方法、抽象工厂

前言,最近看spring的源代码.发现之前没有完全弄懂(工厂方法.抽象工厂)的区别. spring中代理对象的产生,是通过代理工厂(工厂模式),首先spring中的代理是使用jdk或者cglib的代理,只要看目标类是否实现接口. public class ProxyFactory extends ProxyCreatorSupport { //createAopProxy()方法是通过AopProxyFactory获取AopProxy(JDK,CGLIB) public Object getPr

浅谈简单工厂，工厂方法，抽象工厂的区别和使用

工厂模式是分为三种,分别是简单工厂,工厂方法,抽象工厂.其中工厂方法和抽象工厂是GoF23种设计模式中的一种,而简单工厂则不是一种设计模式,更加可以理解的是一种编码时候预定俗称的一种习惯.那么,就在接下来三点中分别去分析理解工厂模式. 一 简单工厂:通过实例化一个工厂类,来获取对应的产品实例.我们不需要关注产品本身如何被创建的细节,只需要通过相应的工厂就可以获得相应的实例.简单工厂包括三种角色: 1.工厂:简单工厂模式的核心,它负责实现创建所有实例的内部逻辑.工厂类的创建产品类的方法可以被外界直

【转】设计模式：简单工厂、工厂方法、抽象工厂之小结与区别

简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式.其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性. 本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解. 简单工厂 简单工厂模式的工厂类一般是使用静态方法,通过接收的参数的不同来返回不同的对象实例. 不修改代码的话,是无法扩展的. 工厂方法 工厂方法是针对每一种产品提供一个工厂类.通过不同的工厂实例来创建不同的产品实例. 在同一等级结构中,支持增加任意产品. 抽象工厂 抽象工厂是应