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

最新推荐文章于 2024-09-02 09:12:00 发布
最新推荐文章于 2024-09-02 09:12:00 发布
阅读量418 收藏 2
点赞数 1
分类专栏： 设计模式 文章标签： 工厂模式 设计模式 简单工厂 工厂方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011519624/article/details/53810719
版权

什么是工厂模式？

　　顾名思义，用工厂去实例化对象，用工厂方法代替new操作。
　　工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

　　从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

UML图

这里写图片描述

　　从UML类图可以看出，简单工厂有三种类，一个是产品基类，一个是产品子类，一个是产品的工厂类。产品工厂类根据不同条件，业务逻辑判断，创建具体的产品对象。

工厂方法模式

　　工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

UML图

这里写图片描述

　　工厂方法模式相对简单工厂模式最明显的不同，在UML图中显而易见。即工厂类演变成了抽象类，且每个工厂各司其职负责创建一个产品，实现了产品与工厂的解耦。

抽象工厂模式

　　为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

UML图

这里写图片描述

　　我们再对比下抽象工厂与工厂方法，不难看出，产品由单一的扩展成为了产品族，而工厂依赖多种产品，加强了对工厂创建产品的扩展。

举个栗子

　　下面以披萨项目为例，加深对工厂模式的理解。
　　披萨项目：要方便披萨品种的扩展，要便于维护，要能运行时扩展。
　　刚开始的披萨有CheesePizza、GreekPizza，用户通过OrderPizza对披萨点单。
Pizza.java

package com.test;

/**
 * 披萨抽象类
 */
public abstract class Pizza {
    protected String name ; 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //准备
    public abstract void prepare();
    //烘焙
    public void bake(){
        System.out.println(name + " is baking……");
    }
    //切割
    public void cut(){
        System.out.println(name + " is cuting……");
    }
    //装盒
    public void box(){
        System.out.println(name + " is boxing……");
    }
}

CheesePizza.java

package com.test;

/**
 * 奶酪披萨
 */
public class CheesePizza extends Pizza {
    public CheesePizza(){
        this.setName("CheesePizza");
    }
    @Override
    public void prepare() {
        System.out.println("prepare Cheese……");
    }
}

GreekPizza.java

package com.test;

/**
 *  希腊披萨
 */
public class GreekPizza extends Pizza {

    public GreekPizza(){
        this.setName("GreekPizza");
    }
    @Override
    public void prepare() {
        System.out.println("prepare Greek……");
    }

}

OrderPizza.java

package com.test;

/**
 * 披萨订单
 */
public class OrderPizza {
    public OrderPizza(String ordertype){
        Pizza pizza = null;
        if("cheese".equals(ordertype)){
            pizza = new CheesePizza();
        }else if("greek".equals(ordertype)){
            pizza = new GreekPizza();
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }

    public static void main(String[] args) {
        new OrderPizza("greek");
    }
}

运行结果：

prepare Greek……
GreekPizza is baking……
GreekPizza is cuting……
GreekPizza is boxing……

　　这样，简单的根据需求产生披萨的1.0版本就实现了，但是如果要增加一种披萨时，则要增加一个披萨类并且修改OrderPizza类，违背了对扩展的开放、对修改关闭的原则。
　　针对以上问题，作以下改进：
　　封装变化，将OrderPizza中创建披萨的过程提取成factory工厂类。
　
SimplePizzaFactory.java 创建披萨的工厂类

package com.test.simpleFactory;

import com.test.CheesePizza;
import com.test.GreekPizza;
import com.test.Pizza;

/**
 * 简单披萨工厂
 */
public class SimplePizzaFactory {
    public Pizza CreatePizza(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }
}

OrderPizza.java 

package com.test.simpleFactory;

import com.test.Pizza;

/**
 * 披萨订单
 */
public class OrderPizza {
    SimplePizzaFactory simplePizzaFactory;
    public OrderPizza(String ordertype){
        simplePizzaFactory = new SimplePizzaFactory();
        Pizza pizza = null;
        pizza = simplePizzaFactory.CreatePizza(ordertype);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }

    public static void main(String[] args) {
        new OrderPizza("greek");
    }
}

运行结果：

prepare Greek……
GreekPizza is baking……
GreekPizza is cuting……
GreekPizza is boxing……

　　按照简单工厂模式设计的披萨项目2.0版本完成，一个工厂类，一个产品抽象类，和一群实现了产品接口的具体产品，而这个工厂类，根据传入的参数去创造一个具体的实现类，并向上转型为接口作为结果返回。但是仍然存在对修改开放的诟病，继续重构。
PizzaFactory.java

package com.test.factoryMethod;

import com.test.Pizza;

/**
 * 披萨工厂抽象类
 */
public abstract class PizzaFactory {
    public abstract Pizza CreatePizza(String orderType);
}
KFCPizzaFactory.java
package com.test.factoryMethod;

import com.test.CheesePizza;
import com.test.GreekPizza;
import com.test.Pizza;

KFCPizzaFactory.java

/**
 * KFC披萨工厂
 */
public class KFCPizzaFactory extends PizzaFactory {
    public Pizza CreatePizza(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }
}

PizzaHutPizzaFactory.java

package com.test.factoryMethod;

import com.test.CheesePizza;
import com.test.GreekPizza;
import com.test.Pizza;

/**
 * 必胜客披萨工厂
 */
public class PizzaHutPizzaFactory extends PizzaFactory {
    public Pizza CreatePizza(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }
}

OrderPizza.java

package com.test.factoryMethod;

import com.test.Pizza;

/**
 * 披萨订单
 */
public class OrderPizza {
    PizzaFactory pizzaFactory;
    public void KFCOrderPizza(String ordertype){
        pizzaFactory = new KFCPizzaFactory();
        Pizza pizza = null;
        pizza = pizzaFactory.CreatePizza(ordertype);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }
    public void PizzaHutOrderPizza(String ordertype){
        pizzaFactory = new PizzaHutPizzaFactory();
        Pizza pizza = null;
        pizza = pizzaFactory.CreatePizza(ordertype);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }

    public static void main(String[] args) {
        OrderPizza order = new OrderPizza();
        order.KFCOrderPizza("greek");
        order.PizzaHutOrderPizza("greek");
    }
}

运行结果

prepare Greek……
GreekPizza is baking……
GreekPizza is cuting……
GreekPizza is boxing……
prepare Greek……
GreekPizza is baking……
GreekPizza is cuting……
GreekPizza is boxing……

　工厂方法模型的实现就完成了，可以看到，我们使用可以随意的在具体的工厂和产品之间切换，并且不需要修改任何代码，就可以让原来的程序正常运行，这也是工厂方法模式对扩展开放的表现，另外工厂方法模式弥补了简单工厂模式不满足开闭原则的诟病，当我们需要增加产品时，只需要增加相应的产品和工厂类，而不需要修改现有的代码。但是目前只针对单一产品，如果要引进“鸡肉”新产品呢？继续改进。
　
Chicken.java

package com.test.abstractFactory;

/**
 * 鸡肉抽象类
 */
public abstract class Chicken {
    protected String name ; 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //准备
    public abstract void prepare();
    //烘焙
    public void bake(){
        System.out.println(name + " is baking……");
    }
    //切割
    public void cut(){
        System.out.println(name + " is cuting……");
    }
    //装盒
    public void box(){
        System.out.println(name + " is boxing……");
    }
}

FriedChicken.java

package com.test.abstractFactory;

/**
 *  炸鸡
 */
public class FriedChicken extends Chicken {

    public FriedChicken(){
        this.setName("RoastChicken");
    }
    @Override
    public void prepare() {
        System.out.println("prepare Chicken……");
    }

}

RoastChicken.java

package com.test.abstractFactory;

/**
 *  烤鸡
 */
public class RoastChicken extends Chicken {

    public RoastChicken(){
        this.setName("RoastChicken");
    }
    @Override
    public void prepare() {
        System.out.println("prepare Chicken……");
    }

}

Factory.java

package com.test.abstractFactory;

import com.test.Pizza;

/**
 * 工厂抽象类
 */
public abstract class Factory {
    public abstract Pizza CreatePizza(String orderType);
    public abstract Chicken CreateChicken(String orderType);
}

KFCFactory.java

package com.test.abstractFactory;

import com.test.CheesePizza;
import com.test.GreekPizza;
import com.test.Pizza;

/**
 * KFC工厂
 */
public class KFCFactory extends Factory {
    public Pizza CreatePizza(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }

    public Chicken CreateChicken(String orderType) {
        Chicken chicken = null;
        if("fried".equals(orderType)){
            chicken = new FriedChicken();
        }else if("roast".equals(orderType)){
            chicken = new RoastChicken();
        }
        return chicken;
    }
}

PizzaHutFactory.java

package com.test.abstractFactory;

import com.test.CheesePizza;
import com.test.GreekPizza;
import com.test.Pizza;

/**
 * 必胜客工厂
 */
public class PizzaHutFactory extends Factory {
    public Pizza CreatePizza(String orderType){
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new CheesePizza();
        }else if("greek".equals(orderType)){
            pizza = new GreekPizza();
        }
        return pizza;
    }
    public Chicken CreateChicken(String orderType) {
        Chicken chicken = null;
        if("fried".equals(orderType)){
            chicken = new FriedChicken();
        }else if("roast".equals(orderType)){
            chicken = new RoastChicken();
        }
        return chicken;
    }
}

OrderPizza.java

package com.test.abstractFactory;

import com.test.Pizza;

/**
 * 订单
 */
public class OrderPizza {
    Factory Factory;
    public void KFCOrderPizza(String ordertype){
        Factory = new KFCFactory();
        Pizza pizza = null;
        pizza = Factory.CreatePizza(ordertype);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }
    public void KFCOrderChicken(String ordertype){
        Factory = new KFCFactory();
        Chicken chicken = null;
        chicken = Factory.CreateChicken(ordertype);
        chicken.prepare();
        chicken.bake();
        chicken.cut();
        chicken.box();
    }
    public void PizzaHutOrderPizza(String ordertype){
        Factory = new PizzaHutFactory();
        Pizza pizza = null;
        pizza = Factory.CreatePizza(ordertype);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }

    public static void main(String[] args) {
        OrderPizza order = new OrderPizza();
        order.KFCOrderPizza("greek");
        order.PizzaHutOrderPizza("greek");
    }
}

　　与工厂方法对比下就发现，多了一个产品系列叫Chinken，工厂接口里多了一个方法，叫CreateChicken，所以抽象工厂模式就是工厂方法模式添加了抽象产品所演变而来的。

总结

　　1，首先从简单工厂进化到工厂方法，是因为工厂方法弥补了简单工厂对修改开放的弊端，即简单工厂违背了开闭原则。
　　2，从工厂方法进化到抽象工厂，是因为抽象工厂弥补了工厂方法只能创造一个系列的产品的弊端。

参考文章：
http://www.cnblogs.com/zuoxiaolong/p/pattern5.html （工厂方法）

IT_tangh
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#编程模式之工厂方法模式+抽象工厂模式
04-17
抽象工厂模式通常由抽象工厂、具体工厂、抽象产品和具体产品组成。通过切换具体工厂实现类，可以改变整个族群。 工厂方法模式：它将对象的创建延迟到子类中进行。由子类决定具体实例化哪个类。通过切换具体工厂的...
Java工厂模式：简单工厂、工厂方法模式、抽象工厂模式代码示例
08-12
在Java中，工厂模式分为三种：简单工厂、工厂方法模式和抽象工厂模式。 **简单工厂模式** 是最基本的工厂模式，它由一个工厂类根据传入的参数决定创建哪一种产品类的实例。简单工厂容易实现，但违反开闭原则，即...
52-简单工厂工厂方法模式抽象工厂1
08-08
简单工厂模式适用于产品种类较少且相对固定的情况，而工厂方法和抽象工厂模式则更适合需要频繁扩展产品线或者有多种产品族的场景。 总的来说，设计模式是解决特定问题的模板，它们提供了一种在面对变化时保持系统...
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】
08-27
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】 Java设计模式之工厂模式是Java设计模式中的一种非常重要的模式，它通过将对象的创建过程与对象的调用者分离，以提高系统的可维护性、可扩展性。工厂...
c++设计模式-抽象工厂方法
06-04
**抽象工厂方法（Abstract Factory Pattern）**是一种创建型设计模式，它提供了一种创建对象族的接口，而具体的对象族由子类决定。在C++中，这种模式可以帮助我们隔离对象的创建和使用，使得代码更加灵活，易于扩展...
活动系统开发之采用设计模式与非设计模式的区别-需求整理
龙哥·三年风水从2011年开始做IT工作，从ps画图到前端开发->后端开发->框架开发->业务架构设计及开发->业务需求整理、开发->技术经理->技术总监
09-01 808
活动系统开发之采用设计模式与非设计模式的区别-需求整理
设计模式之原型模式
2301_76862031的博客
08-31 642
原型模式实现克隆的两种方式，深克隆，创建对象克隆，java代码实现，运行结果 通过复制一个现有的对象实例来创建新对象，而不是通过直接实例化对象。这样可以避免构造过程中的开销，并允许根据需要定制对象的创建过程。
设计模式结构型模式之适配器模式
针线犹存未忍开
08-29 1679
适配器模式是一种结构型设计模式，它允许不兼容的接口之间进行适配，使得原本无法一起工作的类可以协同工作。适配器模式通过引入一个适配器类，将一个类的接口转换成客户端所期待的接口，从而使原本由于接口不兼容而不能一起工作的两个类能够协同工作。适配器模式（Adapter Pattern）是一种结构型设计模式，它允许现有的类与其他类或接口进行协作，解决了类之间接口不兼容的问题。
行为型设计模式-迭代器（Iterator）模式-python实现
最新发布
linkedin_21843693的博客
09-02 756
迭代器模式通过引入迭代器对象，实现了对聚合对象的遍历操作与聚合对象内部结构的解耦，提高了代码的灵活性和可维护性。它广泛应用于各种需要遍历数据集合的场景，比如数据库查询结果的遍历、文件系统的目录遍历等。
设计模式-结构型模式-组合模式
LB_bei的博客
08-29 652
将对象组合成树形结构以表示整个部分的层次结构，组合模式可以让用户统一对待单个对象和对象的组合；其更像是一种数据结构和算法的抽象，其中数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现；
装饰器模式及应用【理论+代码】
东篱君的博客
08-31 613
Pattern）是一种结构型设计模式，它允许向一个现有的对象添加新的功能，同时又不改变其结构。责任分离：装饰器模式将系统的不同功能分离开来，每个装饰器类负责特定的功能扩展。装饰器模式提供了一种灵活的替代继承的方法来扩展对象的行为。通过添加新的装饰器类，可以轻松地为现有对象添加新功能，而不需要修改原有代码。低耦合性：装饰器模式通过组合而非继承来扩展功能，减少了类之间的依赖关系。可以通过添加新的装饰器来扩展系统功能，而不需要修改现有代码。装饰器：持有一个组件对象的引用，并定义一个与组件接口一致的接口。
行为型设计模式-中介者（mediator）模式-python实现
linkedin_21843693的博客
08-30 808
中介者模式通过引入中介者对象，实现了对象之间通信的解耦，使得对象之间的交互更加简单、清晰。它适用于那些对象之间通信复杂、且难以跟踪和维护的场景。通过中介者模式，我们可以提高系统的模块化和可维护性。
设计模式之迭代器模式
2301_76862031的博客
08-29 758
迭代器，java代码实现，例子，代码运行结果，个人理解
设计模式-单例模式
xujinwei_gingko的专栏
09-01 407
饿汉式：类加载时直接创建实例，类加载时已经生成示例，所以。懒汉式：用到实例的时候再创建，多线程场景下，单例模式分为饿汉式、懒汉式。
JS设计模式之“名片设计师” - 工厂方法模式
前端梦工厂
08-31 1368
上篇文章我们了解到什么是简单工厂模式JS设计模式之 “神奇的魔术师” - 简单工厂模式，不过这是工厂中最简单的一种，本篇文章我们将同大家一起认识一种更复杂的工厂模式，它将给我们提供复杂的对象创建场景，以模块化的思想实现我们复杂的需求。就像给我们设计不同的名片一样，我们暂且亲切的称呼它为“名片设计师工厂方法模式）是一种创建型设计模式，在软件开发中被广泛应用。它提供了一种将对象的创建过程封装起来的方式，使得代码可扩展性更好、更灵活。工厂方法模式的主要思想是定义一个用于创建对象的接口。
设计模式之桥接模式
2301_76862031的博客
08-31 779
以车的类型和颜色为例：车的类型可以有很多中（小汽车，卡车，拖拉机等等），汽车的颜色也可以有很多中（红色，白色，黑色等）。
设计模式-结构性模式
weixin_42926863的博客
08-29 887
首先，定义一个所有图形组件都实现的接口，包括基本的图形和符合图形。
Java巅峰之路---进阶篇---面向对象（三）
2301_76909842的博客
08-29 1149
抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样的，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。解释：例如定义一个吃东西的方法，一个程序员认为应该定义为void eat(String name){…}，另一个程序员又认为应该定义为String eat(){…}。这种无法确定方法体，那就在父类中统一确定一种格式，即public abstract void eat();就行抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。
UE开发中的设计模式(四) —— 组合模式
hhhcbw的博客，欢迎各位来访
08-29 1089
组合模式，少继承多组合？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值