首页 > 其他分享 >06【工厂设计模式】

06【工厂设计模式】

时间：2022-12-21 11:36:41浏览次数：37  
标签：06 工厂 抽象 产品 设计模式 小米 public


文章目录

  • ​​六、工厂设计模式​​
  • ​​6.1 简单工厂设计模式​​
  • ​​6.1.1 设计需求​​
  • ​​6.1.2 使用接口改进代码​​
  • ​​6.1.3 使用简单工厂再改进​​
  • ​​6.1.4 简单工厂的优缺点​​
  • ​​6.2 工厂方法设计模式​​
  • ​​6.2.1 工厂方法的实现​​
  • ​​6.2.2 工厂方法的优缺点​​
  • ​​6.3 抽象工厂设计模式​​
  • ​​6.3.1 抽象工厂设计模式概述​​
  • ​​1）同族和同级​​
  • ​​2）同族的概念​​
  • ​​6.3.2 抽象工厂的实现​​
  • ​​6.3.3 抽象工厂的优缺点​​

六、工厂设计模式

工厂设计模式，顾名思义，就是用来生产对象的，在Java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则（一个好的软件实体应该对扩展开放，对修改关闭）；另外，如果创建一个类的过程过于复杂，如需要传递过多的构造方法参数等，那么创建对象将会变得非常麻烦，并且会与其他业务类进行耦合。当这个类发生修改时，就需要在任何引用该类的源代码处进行修改；后期维护成本将会变得巨大；

如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；

工厂设计模式分为三种，分别为简单工厂设计模式、工厂方法设计模式、抽象工厂设计模式；

6.1 简单工厂设计模式

简单工厂模式（Simple Factory）：简单工厂模式又称为静态工厂方法模型，它属于类创建型模式。在简单工厂模式中，可以根据方法的参数不同返回不同类的实例。简单工厂专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

Tips：简单工厂设计模式不在GoF23种设计模式之中；

6.1.1 设计需求

  • 设计一个计算类，具备基本的加减乘除方法：
package com.dfbz.demo01_简单工厂设计模式.demo01_需求;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Operation {

    /**
     * 计算方法
     * @param num1
     * @param num2
     * @param operate
     * @return
     */
    public static Double getResult(double num1, double num2, String operate) {

        Double result = 0.0D;
        switch (operate) {
            case "+":
                result = num1 + num2;
                break;
            case "-":
                result = num1 - num2;
                break;
            case "*":
                result = num1 * num2;
                break;
            case "/":
                result = num1 / num2;
                break;
        }
        return result;
    }
}
  • 测试类：
package com.dfbz.demo01_简单工厂设计模式.demo01_需求;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_测试加减乘除计算类 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个数: ");
        double num1 = scanner.nextDouble();
        System.out.println("请输入第一个数: ");
        double num2 = scanner.nextDouble();

        System.out.println("请输入您要执行的运算符(+、-、*、/): ");
        String operate = scanner.next();

        Double result = Operation.getResult(num1, num2, operate);
        System.out.println("运算的结果: " + result);
    }
}

6.1.2 使用接口改进代码

在上述案例程序中，代码耦合性太高，假设程序需要改进加法算法，则必须把所有的代码全部提供；并且由于所有的算法都在一起，试想一下假设一个加法算法的代码在几千行，那么程序将变得难以维护，不利于各个部件的单独升级，我们要做的是将各个部件独立出来；这样方便以后的升级扩展，并且各个模块相对独立；

  • 设计计算类的顶层接口：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface Operation {
    /**
     * 负责计算两个两个数的运算结果集,到底做什么运算,交给子类
     * @param num1
     * @param num2
     * @return
     */
    public Double getResult(Double num1,Double num2);
}
  • 加法类：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationAdd implements Operation{
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 + num2;
    }
}
  • 减法类：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationSub implements Operation {
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 - num2;
    }
}
  • 测试代码：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;


import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个数: ");
        double num1 = scanner.nextDouble();
        System.out.println("请输入第一个数: ");
        double num2 = scanner.nextDouble();

        System.out.println("请输入您要执行的运算符(+、-、*、/): ");
        String operate = scanner.next();

        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
        }

        Double result = operation.getResult(num1, num2);

        System.out.println("计算的结果集为: " + result);
    }
}

6.1.3 使用简单工厂再改进

使用接口改进后的代码各个部件相对独立，如果以后需要修改加法类的算法也不用提供其他算法类的具体实现；但是上述代码中还存在一个具体的问题，那就是如果以后新增了其他的算法，源代码则需要一直改变；这样违反了开闭原则，我们的程序应该是"对扩展开放，对修改关闭"；即类可以新增，但源代码尽量不要再修改；

  • 设计一个工厂类：
package com.dfbz.demo01_简单工厂设计模式.demo03_使用简单工厂再改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationFactory {
    /**
     * 根据计算方式来选择创建对应的对象
     *
     * @param method
     * @return
     */
    public static Operation createOperation(String method) {

        Operation operation = null;
        if (method.equals("+")) {
            operation = new OperationAdd();
        } else if (method.equals("-")) {
            operation = new OperationSub();
        }
        return operation;
    }

}
  • 测试类：
package com.dfbz.demo01_简单工厂设计模式.demo03_使用简单工厂再改进;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个数: ");
        double num1 = scanner.nextDouble();
        System.out.println("请输入第一个数: ");
        double num2 = scanner.nextDouble();

        System.out.println("请输入您要执行的运算符(+、-、*、/): ");
        String method = scanner.next();

        Operation operation = OperationFactory.createOperation(method);

        Double result = operation.getResult(num1, num2);
        System.out.println("计算的结果集为: " + result);
    }
}

就这样，一个简单工厂设计模式就完成了。在简单工厂模式下，任何的运算逻辑新增或者修改，都不会影响客户端的代码（Demo01），只需要添加Operation的实现类，并且修改工厂类添加逻辑即可；降低了程序的耦合性；

但是，简单工厂只做到了一半的"开闭原则"，因为在简单工厂中，新增了新的算法类，需要修改工厂类；如果我们需要频繁的新增一些算法则会导致频繁修改工厂类；简单工厂中，不仅对扩展开放了，对修改也开放了；

Tips：简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适；

6.1.4 简单工厂的优缺点

  • 优点：
  • 封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
  • 缺点：
  • 1）增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。
  • 2）简单工厂模式的工厂类单一，负责所有产品的创建，但产品基数增多时，工厂类将会变得非常臃肿，违背高内聚低耦合原则；

6.2 工厂方法设计模式

工厂设计模式（Factory Method）：指定一个创建对象的接口，由接口的实现类来决定实例化哪个类，工厂方法把类的实例化工作延迟到子类中进行；

在简单工厂中，随着产品链的丰富，则工厂的职责会变得越来越多，这样并不利于维护。工厂方法模式是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

6.2.1 工厂方法的实现

工厂方法中，不仅把产品抽象出来，连工厂类也抽象出来，具体生成什么产品由子类来决定；

  • 改进后的类图如下：

06【工厂设计模式】_抽象工厂模式

在工厂方法中，如果要对算法进行扩展，那么就新增一个工厂并且再新增一个具体算法类即可，工厂方法完全符合了开闭原则的对扩展开发，对修改关闭的原则；

  • 工厂抽象接口：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface IFactory {
    Operation createOperation();
}
  • 产品抽象接口：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface Operation {
    /**
     * 负责计算两个两个数的运算结果集,到底做什么运算,交给子类
     * @param num1
     * @param num2
     * @return
     */
    public Double getResult(Double num1,Double num2);
}
  • 专门用于生成加法产品的工厂类：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationAddFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}
  • 专门用于生成减法产品的工厂类：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationSubFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}
  • 加法产品：
package com.dfbz.demo02_工厂设计模式;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationAdd implements Operation {
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 + num2;
    }
}
  • 减法产品：
package com.dfbz.demo02_工厂设计模式;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationSub implements Operation {
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 - num2;
    }
}
  • 测试类：
package com.dfbz.demo02_工厂设计模式;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建工厂
        IFactory factory=new OperationAddFactory();

        // 创建运算类
        Operation operation = factory.createOperation();

        // 做运算
        Double result = operation.getResult(20.0D, 30.0D);
    }
}

工厂方法完完全全做到了开闭原则，以后我们要新增一些算法，或者第三方厂商想要新增一些算法，那么直接进行子类扩展就行；

6.2.2 工厂方法的优缺点

  • 优点：
  • 1）职责相对于简单工厂来说，更加明确。不仅将产品类独立，还将产品工厂独立，以后修改产品工厂内部逻辑变得清晰明了；
  • 2）在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
  • 3）高层模块只需要知道产品的抽象类，无须关系其他实现类，符合迪米特法则，依赖倒转原则；
  • 缺点：
  • 1）每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，类的数量增多，这增加了系统的复杂度。
  • 2）每个工厂只能生产一种产品，该问题可以使用抽象工厂来解决。

6.3 抽象工厂设计模式

6.3.1 抽象工厂设计模式概述

在工厂方法设计模式中，工厂生产的是总是同一类的产品；例如产品1工厂只能生产产品1，产品2工厂只能生产产品2；这些工厂只生产同种类产品，而抽象工厂模式将考虑多种类产品的生产。在抽象工厂中，将同一种工厂生产出来的产品称为同族产品，而同一种工厂生产出来的不同产品称为同级产品；

例如电子设备工厂能够生产手机，笔记本；旗下有小米工厂，华为工厂；小米工厂能够生产小米手机，小米笔记本；华为工厂能够生产华为手机，华为笔记本；

程序类图如下：

06【工厂设计模式】_设计模式_02

06【工厂设计模式】_设计模式_03

  • 同族产品：
  • 小米手机，小米笔记本属于同族产品，都属于小米品牌（都属于小米工厂创建的产品）
  • 华为手机，华为笔记本属于同族产品，都属于华为品牌（都属于华为工厂创建的产品）
  • 同级产品：
  • 小米手机，华为手机属于同级产品，都属于手机产品
  • 小米笔记本，华为笔记本属于同级产品，都属于笔记本产品

1）同族和同级

同族：只要是同一个工厂生产的产品都属于同族产品；

06【工厂设计模式】_java_04

  • 小米，小米手机，小米笔记本，小米智能机，小米老年机，小米游戏本，小米商务本等都属于小米工厂生产的产品，属于同族；

同级：工厂生产出来的产品的类别称为级别，所属同一个类别的产品，那么就是同级别产品；

06【工厂设计模式】_工厂方法模式_05

  • 小米手机，华为手机都是属于手机，属于同级产品；
  • 小米笔记本，华为笔记本都是属于笔记本，属于同级产品；

2）同族的概念

同族是有相对概念的问题，主要看我们的程序是如何设计的

  • 关于同族：只要是同一个工厂生产的产品都属于同族产品；
  • 关于同级：工厂生产出来的产品的类别称为级别，所属同一个类别的产品，那么就是同级别产品；

例如，在下面类图中，同族与同级的关系发生了变化：

06【工厂设计模式】_简单工厂模式_06

06【工厂设计模式】_工厂方法模式_07

同族产品：

06【工厂设计模式】_设计模式_08

  • 小米智能机，华为智能机属于同族产品，都属于老年机厂商生产的产品
  • 小米老年机，华为老年机属于同族产品，都属于智能机厂商生产的产品

同级产品：

06【工厂设计模式】_简单工厂模式_09

  • 小米智能机，小米老年机属于同级产品；都属于小米类别
  • 华为智能机，华为老年机属于同级产品；都属于华为类别

6.3.2 抽象工厂的实现

抽象工厂模式的主要角色如下。

  1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
  2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
  3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
  4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

基于类图设计程序：

06【工厂设计模式】_抽象工厂模式_10

抽象工厂：

package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 电子设备工厂, 用于生产电子设备
 */
public abstract class AbstractFactory {

    // 生产手机
    public abstract Phone createPhone();

    // 生产笔记本
    public abstract Laptop createLaptop();
}
  • 具体工厂1-小米工厂：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 小米工厂,用于生产小米的设备
 */
public class XiaoMiFactory extends AbstractFactory{
    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }

    @Override
    public Laptop createLaptop() {
        return new XiaoMiLaptop();
    }
}
  • 具体工厂2-华为工厂：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 华为工厂,用于生产华为的设备
 */
public class HuaWeiFactory extends AbstractFactory {
    @Override
    public Phone createPhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Laptop createLaptop() {
        return new HuaWeiLaptop();
    }
}
  • 抽象产品1-手机：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 抽象产品,抽象手机,每个手机的功能是不一样的,具体的实现交给子类
 */
public abstract class Phone {

    public abstract void sendMsg();
}
  • 抽象产品2-笔记本：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 抽象产品,抽象笔记本,每个笔记本的功能是不一样的,具体的实现交给子类
 */
public abstract class Laptop {
    public abstract void play();
}
  • 具体产品1-小米手机：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class XiaoMiPhone extends Phone {
    @Override
    public void sendMsg() {
        System.out.println("使用小米手机发送短信....");
    }
}
  • 具体产品2-小米笔记本：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class XiaoMiLaptop extends Laptop {
    @Override
    public void play() {
        System.out.println("使用小米笔记本打游戏...");
    }
}
  • 具体产品3-华为手机：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class HuaWeiPhone extends Phone {
    @Override
    public void sendMsg() {
        System.out.println("使用华为手机发送短信....");
    }
}
  • 具体产品4-华为笔记本：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class HuaWeiLaptop extends Laptop {
    @Override
    public void play() {
        System.out.println("使用华为笔记本打游戏...");
    }
}
  • 测试类：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        // 使用华为工厂来创建电子设备
        AbstractFactory factory=new HuaWeiFactory();
        Laptop laptop = factory.createLaptop();
        Phone phone = factory.createPhone();

        laptop.play();
        phone.sendMsg();

        System.out.println("----------");

        // 使用小米工厂来创建电子设备
        AbstractFactory factory2=new XiaoMiFactory();
        Laptop laptop2 = factory.createLaptop();
        Phone phone2 = factory.createPhone();

        laptop2.play();
        phone2.sendMsg();
    }
}

6.3.3 抽象工厂的优缺点

  • 优点：
  • 1）类的继承体系结构清晰明确，对类的管理方便
  • 2）有了抽象工厂，当新增一个产品族时，不需要修改源代码，例如还要新增一个联想产品族，只需要自己编写联想工厂，联想手机，联想笔记本等即可，程序的扩展性强，符合开闭原则；
  • 3）当一个产品线中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品线中的对象。
  • 缺点：
  • 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。例如抽象工厂不仅要生产手机和笔记本要生产电视机，那么所有的工厂包括小米工厂，华为工厂等都行呀新增对生产电视机这种产品的实现；


标签：06,工厂,抽象,产品,设计模式,小米,public
From： https://blog.51cto.com/u_15919174/5959173

相关文章

  • 07【建造者设计模式】
    文章目录​​七、建造者设计模式​​​​7.1建造者设计模式简介​​​​7.2建造者设计模式的实现​​​​7.2.1案例引入​​​​1）UML类图如下：​​​​2）建造者设计模式中......
  • 08【代理设计模式】
    文章目录​​八、代理设计模式​​​​8.1结构型设计模式简介​​​​8.2代理设计模式简介​​​​8.2.1代理设计模式概述​​​​8.2.2代理设计模式的UML类图​​​​8......
  • 09【享元设计模式】
    九、享元设计模式9.1享元设计模式简介9.1.1享元设计模式概述享元模式（FlyweightPattern）：享元模式主要的任务就是减少对象创建的数量，其宗旨是共享细粒度的对象，将多个对同一......
  • 设计模式-责任链模式
    概念责任链模式是一种行为设计模式就是将一个东西（入参）按步骤顺序处理每一个步骤（一个个实际处理入参的对象：可以抽出公共的接口或抽象类）对应相应的处理方式东西通过......
  • day06-功能实现05
    家居网购项目实现05以下皆为部分代码，详见https://github.com/liyuelian/furniture_mall.git12.功能11-后台分页(分页显示家居)12.1需求分析/图解管理员进入到家居......
  • 设计模式，mvc,mvp,mvvm
    mvcmodel模型-视图view-控制器controller视图可以直接访问模型，所以视图里面包括模型信息，mvc关注的是模型不变，所以在mvc中，模型不依赖视图，但是view是依赖model的原理：模......
  • 力扣-406-根据身高重建队列
    第一眼觉得有一种逆向单调栈的既视感看评论区举了一个很生动形象的例子，自己还是写不出来vector<vector<int>>reconstructQueue(vector<vector<int>>&people){ vector......
  • 彩虹女神跃长空,Go语言进阶之Go语言高性能Web框架Iris项目实战-登录与图形验证码(capt
    书接上回，上一回我们按照“低耦合高内聚”的组织架构方针对项目的整体结构进行了优化，本回将会继续编写业务，那就是用户的登录逻辑，将之前用户管理模块中添加的用户账号进行账......
  • 设计模式之六大原则
    关于设计模式的六大设计原则的资料网上很多，但是很多地方解释地都太过于笼统化，我也找了很多资料来看，发现CSDN上有几篇关于设计模式的六大原则讲述的比较通俗易懂，因此转载过来......
  • java中的模板设计模式【抽象类的最佳实践】
    本文主要讲述抽象类最佳实践，模板设计模式。老韩的介绍：示例代码如下：1/**2*需求：计算出执行一个job()方法，所需要花费的时间.3*使用模板设计模式【抽......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99