设计模式——工厂模式（附代码示例）

已于 2023-03-10 17:15:23 修改
阅读量3.5k 收藏 26
点赞数 6
分类专栏： 设计模式 文章标签： 设计模式 简单工厂模式 抽象工厂模式 工厂方法模式
于 2022-05-20 22:41:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43899792/article/details/124888948
版权

一. 传统方法

以订购披萨为例

1. 代码示例

        将Pizza类做成抽象类，定义准备、烘烤、切割、打包等方法，其中因不同披萨原材料不一样，因此准备的方法做成抽象方法

public abstract class Pizza {
    protected String name;
    //准备原材料,不同披萨不一样，因此做成抽象方法
    public abstract void prepare();
    public void setName(String name){
        this.name = name;
    }
    public void bake(){
        System.out.println(name + " 烘烤中");
    }
    public void cut(){
        System.out.println(name + " 切割中");
    }
    public void box(){
        System.out.println(name + " 打包中");
    }
}

        GreekPizza类继承Pizza类，表示制作希腊披萨

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作希腊披萨 准备原材料");
    }
}

        CheesePizza类继承Pizza类，表示制作奶酪披萨 

public class CheesePizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作奶酪披萨 准备原材料");
    }
}

        OrderPizza类，表示根据不同披萨类型进行订购，并执行不同披萨的制作流程（存在多处OrderPizza1，OrderPizza2，OrderPizza3）

public class OrderPizza {
    //构造器
    public OrderPizza(){
        Pizza pizza = null;
        String orderType;//订购披萨类型
        do{
            orderType = getType();
            if(orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("greek");
            }else if(orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("cheese");
            }else {
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while(true);
    }
    //获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("输入订购披萨类型：");
            String str = null;
            str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

         PizzaStore类，相当于客户端，完成订购任务

public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}

          执行结果

2. 类图

3. 传统方法优缺点分析

        优点是比较好理解，简单易操作。

        缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

        比如我们这时要新增加一个Pizza的种类(Butter披萨)，需要做如下修改

 

        修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处。（如果有多处OrderPizza，每一处都要改）

        改进：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有创建到Pizza对象的代码就不需要修改了，因此引入简单工厂模式

二. 简单工厂模式

1. 概念

        简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。简单工厂模式定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)。在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

2. 代码示例 

        将Pizza类做成抽象类，定义准备、烘烤、切割、打包等方法，其中因不同披萨原材料不一样，因此准备的方法做成抽象方法

public abstract class Pizza {
    protected String name;
    //准备原材料,不同披萨不一样，因此做成抽象方法
    public abstract void prepare();
    public void setName(String name){
        this.name = name;
    }
    public void bake(){
        System.out.println(name + " 烘烤中");
    }
    public void cut(){
        System.out.println(name + " 切割中");
    }
    public void box(){
        System.out.println(name + " 打包中");
    }
}

        GreekPizza类继承Pizza类，表示制作希腊披萨

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作希腊披萨 准备原材料");
    }
}

        CheesePizza类继承Pizza类，表示制作奶酪披萨 

public class CheesePizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("制作奶酪披萨 准备原材料");
    }
}

        SimpleFactory类，表示一个简单工厂，在工厂中实现创建披萨

public class SimpleFactory {
    public Pizza createPizza(String orderType){
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if(orderType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("greek");
        }else if(orderType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("cheese");
        }
        return pizza;
    }
}

        OrderPizza类，表示根据不同披萨类型进行订购，并执行不同披萨的制作流程（存在多处OrderPizza1，OrderPizza2，OrderPizza3），创建披萨由简单工厂实现

public class OrderPizza {
    //定义一个简单工厂对象
    SimpleFactory simpleFactory;
    Pizza pizza = null;
    //构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }
    public void setFactory(SimpleFactory simpleFactory) {
        String orderType = ""; //用户输入的
        this.simpleFactory = simpleFactory; //设置简单工厂对象
        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            //输出pizza
            if(pizza != null) { //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        }while(true);
    }

    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

          PizzaStore类，相当于客户端，完成订购任务

public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new SimpleFactory());
    }
}

        执行结果

3. 类图

4. 简单工厂模式优缺点分析

        与传统方法相比较，把创建Pizza对象封装到简单工厂类中，这样我们有新的Pizza种类时，只需要修改简单工厂类即可，其它有创建到Pizza对象的代码就不需要修改了（即使有多处OrderPizza，也只修改简单工厂类即可）

三. 工厂方法模式

 1. 概念

        定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类

2. 代码示例

        假如披萨项目有了新的需求，客户在点披萨时，可以点不同地方的披萨，比如北京的奶酪pizza、北京的黄油pizza或者是伦敦的奶酪pizza、伦致的黄油pizza。工厂方法模式设计，将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。

        将Pizza类做成抽象类，定义准备、烘烤、切割、打包等方法，其中因不同披萨原材料不一样，因此准备的方法做成抽象方法

public abstract class Pizza {
    protected String name;
    //准备原材料,不同披萨不一样，因此做成抽象方法
    public abstract void prepare();
    public void setName(String name){
        this.name = name;
    }
    public void bake(){
        System.out.println(name + " 烘烤中");
    }
    public void cut(){
        System.out.println(name + " 切割中");
    }
    public void box(){
        System.out.println(name + " 打包中");
    }
}

        BJCheesePizza类，表示制作北京口味的奶酪披萨

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println(name+",准备原材料");
    }
}

        BJGreekPizza类，表示制作北京口味的希腊披萨 

public class BJGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京希腊披萨");
        System.out.println(name+",准备原材料");
    }
}

         LDCheesePizza类，表示制作伦敦口味的奶酪披萨

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println(name+",准备原材料");
    }
}

         LDGreekPizza类，表示制作伦敦口味的希腊披萨

public class LDGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦希腊披萨");
        System.out.println(name + ",准备原材料");
    }
}

         OrderPizza抽象类，表示一个工厂，具体的创建披萨的方法（抽象方法）由工厂子类实现

public abstract class OrderPizza {
    //定义一个抽象方法，createPizza，让各个工厂子类自己实现
    abstract Pizza cratePizza(String orderType);
    //构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            pizza = cratePizza(orderType);//抽象方法，由工厂子类完成
            if(pizza != null) { //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        }while (true);
    }
    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

         BJOderPizza类，表示工厂的一个子类，创建北京口味的披萨

public class BJOderPizza extends OrderPizza{
    @Override
    Pizza cratePizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if(orderType.equals("greek")){
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

         LDOderPizza类，表示工厂的一个子类，创建伦敦口味的披萨

public class LDOderPizza extends OrderPizza{
    @Override
    Pizza cratePizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        }else if(orderType.equals("greek")){
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

         PizzaStore类，相当于客户端，完成订购任务

public class PizzaStore {
    public static void main(String[] args) {
        //创建北京口味的各种披萨
        new BJOderPizza();
    }
}

        执行结果

3. 类图 

        

四. 抽象工厂模式

 1. 概念

       抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

       抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

2. 代码示例

         将Pizza类做成抽象类，定义准备、烘烤、切割、打包等方法，其中因不同披萨原材料不一样，因此准备的方法做成抽象方法

public abstract class Pizza {
    protected String name;
    //准备原材料,不同披萨不一样，因此做成抽象方法
    public abstract void prepare();
    public void setName(String name){
        this.name = name;
    }
    public void bake(){
        System.out.println(name + " 烘烤中");
    }
    public void cut(){
        System.out.println(name + " 切割中");
    }
    public void box(){
        System.out.println(name + " 打包中");
    }
}

        BJCheesePizza类，表示制作北京口味的奶酪披萨

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println(name+",准备原材料");
    }
}

        BJGreekPizza类，表示制作北京口味的希腊披萨 

public class BJGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京希腊披萨");
        System.out.println(name+",准备原材料");
    }
}

         LDCheesePizza类，表示制作伦敦口味的奶酪披萨

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println(name+",准备原材料");
    }
}

         LDGreekPizza类，表示制作伦敦口味的希腊披萨

public class LDGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦希腊披萨");
        System.out.println(name + ",准备原材料");
    }
}

        AbsFactory接口，表示一个抽象工厂模式的抽象层（接口），内部定义创建披萨的方法

public interface AbsFactory {
    public Pizza createPizza(String orderType);
}

       BJFactory类，表示一个具体的工厂，创建北京口味的披萨

public class BJFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用抽象工厂模式");
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if(orderType.equals("greek")){
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

        LDFactory类，表示一个具体的工厂，创建伦敦口味的披萨

public class LDFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用抽象工厂模式");
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        }else if(orderType.equals("greek")){
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

         OrderPizza类，表示根据披萨类型制作不同口味披萨，具体的披萨创建由工厂簇实现

public class OrderPizza {
    AbsFactory absFactory;
    //构造器
    public OrderPizza(AbsFactory absFactory){
        setAbsFactory(absFactory);
    }
    public void setAbsFactory(AbsFactory absFactory){
        Pizza pizza = null;
        String orderType = "";
        this.absFactory = absFactory;
        do {
            orderType = getType();
            pizza = this.absFactory.createPizza(orderType);
            //输出pizza
            if(pizza != null) { //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        }while (true);
    }
    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

        PizzaStore类，相当于客户端，完成订购任务 

public class PizzaStore {
    public static void main(String[] args) {
        //创建北京口味的各种披萨
        new OrderPizza(new BJFactory());
    }
}

        执行结果

   

3. 类图

五. 总结 

1. 工厂模式的意义

        将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展和维护性。

2. 三种工厂模式

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

3. 设计模式的依赖抽象原则

        1. 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中并返回。有的书上说，变量不要直接持有具体类的引用。

        2. 不要让类继承具体类， 而是继承抽象类或者是实现interface(接口)

        3. 不要覆盖基类中已经实现的方法。 

枫陵
关注
  • 6
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
设计模式 | 用实际案例详解工厂模式
小白菜的博客
06-06 1184
我们来看一个具体需求 看一个披萨的项目，要便于披萨种类的扩展，要便于维护，有以下要求： 披萨的种类很多（比如GreekPizz、CheesePizz等） 披萨的制作有prepare，bake，cut，box 完成披萨店订购功能 首先我们先编写一个Pizza抽象类： package com.cxc.factory.simplefactory.pizzastore.pizza; /** * 抽...
设计模式详解（一）——工厂方法模式
weixin_41951205的博客
09-18 435
前言 前面我们介绍了简单工厂模式，它将创建对象的细节隐藏起来，客户端仅仅通过参数来决定生产哪种具体的产品。但是该模式有个较大的缺点，当我们增加新产品的时候就需要修改工厂类的逻辑，导致原来的商品创建逻辑可能受到影响，即违背了开闭原则。因此我们提出了工厂方法模式。 一、场景问题 在实际工作中，我们经常需要导出一些数据，这些数据可能是Excel模式、文本格式、XML格式或数据库脚本格式等等，总之一系列的数据文件格式，未来也有各种各样的导出格式需求. 二、解决方案 1、传统解决方案 即简单工厂模式，缺点上面也说明了
设计模式之简单工厂模式案例
07-09
设计模式之简单工厂模式案例
Java工厂模式介绍与代码样例
最新发布
li_Michael的博客
06-11 454
但是，简单工厂模式有一个缺点，即当需要增加新的产品时，需要修改工厂类的代码，这违反了开闭原则（对扩展开放，对修改关闭）。工厂模式（Factory Pattern）是Java中常用的一种创建型设计模式，它提供了一种封装机制，将对象的创建与使用分离，使得代码结构更加清晰，同时降低了对象之间的耦合度。工厂模式主要解决了“对象如何创建”的问题，使得我们可以使用相同的接口来创建不同的对象。工厂模式是一种常用的创建型设计模式，它将对象的创建与使用分离，使得代码结构更加清晰，同时降低了对象之间的耦合度。
设计模式之工厂模式
BASK2312的博客
06-20 237
工厂模式有三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。简单工厂模式是最基本的工厂模式，它通过一个工厂类来创建所有需要的对象。简单工厂模式将对象的创建逻辑封装在一个工厂类中，客户端通过调用工厂类的静态方法来创建对象。工厂方法模式是对简单工厂模式的改进，它定义了一个用于创建对象的接口或抽象类，让子类决定实例化哪一个类。工厂方法模式将对象的创建过程延迟到子类中进行，从而实现了开闭原则。
工厂模式-代码
qq_37343656的博客
03-16 1018
简单工厂和抽象工厂模式
Java设计模式-工厂模式
Java硬件工程师的博客
02-09 3374
1.概述 需求：设计一个咖啡店点餐系统。 设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。 具体类的设计如下： 在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重(CoffeeStore对AmericanCoffr)，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果
设计模式——工厂模式（Factory）
矩阵实验室
11-05 1371
1. 定义 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 Product：负责定义产品的共性，实现对事物最抽象定义； Creator：抽象创建类，也就是抽象工厂 ConcreteCreator：实现具体如何创建产品类 2. 优点 （1）良好的封装性，代码结构清晰 一个对象创建是有条件约束的，如一个调用者需要一个具体的产品
Java设计模式：工厂模式——图文+代码示例（通俗易懂）
12-21
Java设计模式中的工厂模式是一种创建型设计模式，其主要目的是为了解耦对象的创建与使用。工厂模式通过提供一个统一的接口或类来创建对象，使得客户端代码无需直接实例化对象，而是通过调用工厂方法来获取所需的对象...
设计模式——工厂方法模式
08-10
在这个压缩包中，`FactoryMethod`可能包含了Java实现工厂方法模式的源代码示例。 设计模式是一种在特定场景下解决软件设计问题的通用、可重用的解决方案，它代表了最佳实践，被广泛应用于各种编程语言中。工厂方法...
设计模式之美——教你写出高质量代码
04-10
"设计模式之美——教你写出高质量代码"这个主题旨在帮助开发者更好地理解和应用设计模式，从而提升代码的质量和可维护性。设计模式不仅对面试有所帮助，也是职场发展中的必备技能，无论你使用哪种开发语言。 设计...
设计模式——简单工厂模式
08-10
**设计模式——简单工厂模式** 简单工厂模式是创建型设计模式的一种，它提供了一种创建对象的最佳方式。在简单工厂模式中，一个专门的类（称为工厂类）负责创建对象，客户端无需知道所创建的对象的具体类，只需要...
抽象工厂设计模式code
04-11
抽象工厂设计模式是一种创建型设计模式，它提供了一种创建对象族的方法，而无需指定具体的类。这种模式在处理相关对象族的创建时特别有用，因为它允许创建一组具有相同接口的对象，而无需指定它们的具体类型。C#作为...
三大工厂模式的代码实现及总结
m0_37857539的博客
05-06 208
简单工厂模式 工厂方法模式 抽象工厂方法
Java设计模式--工厂模式
南方嘉木的博客
02-03 1682
依赖抽象原则：创建对象实例时，不要之间new类，而是把这个动作交给工厂的方法并返回。
Java设计模式：简单工厂模式（附实例代码）每天一学设计模式
weixin_42199290的博客
02-10 6300
简单工厂模式又称为静态工厂模式：定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有相同的父类。虽然不属于23中设计模式其一，但是经常会被使用。 /**Product抽象产品角色*/ public abstract class Product{ //所有产品类的公共业务方法 public void methodSame(){ //公共方法的实现 } //声明抽象业务方法 public abstract void methodDiff
设计模式创建型——工厂模式
tszc95的博客
04-04 4259
工程模式是通过工厂获取一个一个的新对象。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
设计模式-工厂方法模式实例-01
LYly_B的博客
03-02 895
设计模式-工厂方法模式实例-01 工厂方法模式/虚拟构造器模式/多态工厂模式(类创建型模式) 要点： 符合开闭原则。 优点： 向客户隐藏了那种具体产品将被实例化； 能让工厂自主确定创建何种产品对象； 加入新产品时符合开闭原则。 缺点： 类的个数成对增加，在一定程度上增加了系统复杂度，带来额外开销； 增加了系统抽象性和理解难度。 适用环境： 客户端不需要知道它所需要知道的对象的类； 抽象工厂通过其...
工厂模式超详解（代码示例）
热门推荐
Java成魔之路
11-20 2万+
工厂模式概述 工厂模式的主要解决的问题是，将原来分布在各个地方的对象创建过程单独抽离出来，交给工厂类负责创建。其他地方想要使用对象直接找工厂（即调用工厂的方法）获取对象。 工厂模式的三种类型 工厂模式主要有三种类型 1、简单工厂 2、工厂方法 3、抽象工厂 简单工厂 拿泡茶为例，茶叶有好多种类，比如龙井、碧螺春、毛尖等。 首先一个ITea接口： public interface ITea { ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值