简单工厂模式

最新推荐文章于 2024-08-05 14:28:44 发布
最新推荐文章于 2024-08-05 14:28:44 发布
阅读量473 收藏
点赞数
分类专栏： UML-与设计模式 文章标签： 设计模式 简单工厂模式 解决方案 重构 编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37674257/article/details/70939547
版权

【问题引入】

初始情况：A 类实例与 B 类实例通过硬编码耦合(即 A 类实例中的方法直接使用 new 关键字创建 B 类实例

系统重构要求：使用 C 类实例来代替系统中的 B 类实例

问题：如果系统中有100个或者10000个使用 B 类实例的地方，是否只能通过逐个的将 B 类实例修改为 C 类的实例来完成系统的重构呢？有没有更好的解决方案？

【解决方案】

考虑让 B 类实现一个 IB 接口，而 A 类只需要和 IB 接口耦合——A 类个并不直接使用 new 关键字来创建 B 类实例，而是重新定义一个工厂类：IBFactory, 由该工厂类负责创建 IB 实例；而 A 类通过调用 IBFactory 工厂的方法类得到 IB 的实例。

【应用场景 A —— Computer 与 Outpet 实现类的解耦】

1. 具体问题

假设程序中有个 Computer 对象需要依赖一个输出设备，现在有两个选择：直接让 Computer 对象依赖一个 Printer 对象(实现类)，或者让 Computer 对象依赖一个 Output 属性(接口)，选用哪种方式更好？为什么？如果系统需要重构，即替换系统中的 Printer 对象为其他对象，应该怎样设计重构方案？

2. 方案设计

为使系统具有更好的可维护性和可扩展性，一般选用工厂模式。根据简单工厂设计模式，程序应该让 Computer 依赖一个 Output 属性，将 Computer 类与 Printer 实现类分离开来。Computer 对象只需面向 Output 接口编程即可；而 Computer 具体依赖于 Output 的那个实现类则完全透明。

3. 代码实现

Computer.java
public class Computer {

    private Output out;

    // 通过构造器注入方式实现 Computer 类与 Output 接口的耦合
    public Computer(Output out) {
        this.out = out;
    }

    // 定义一个模拟获取字符串输入的方法
    public void keyIn(String msg) {
        out.getData(msg);
    }

    // 定义一个模拟打印的方法
    public void print() {
        out.out();
    }

    public static void main(String[] args) {

        // 创建OutputFactory
        OutputFactory of = new OutputFactory();
        // 将Output对象传入，创建Computer对象
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();

    }
}
Output.java
public interface Output {

    // 接口里定义的属性只能是常量
    public static final int MAX_CACHE_LINE = 50;

    // 接口里定义的只能是public的抽象实例方法
    public void out();

    public void getData(String msg);
}
Printer.java
// 让Printer类实现Output
public class Printer implements Output {

    private String[] printData = new String[MAX_CACHE_LINE];

    // 用以记录当前需打印的作业数
    private int dataNum = 0;

    public void out() {
        // 只要还有作业，继续打印
        while (dataNum > 0) {
            System.out.println("打印机打印：" + printData[0]);
            // 把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

    public void getData(String msg) {
        if (dataNum >= MAX_CACHE_LINE) {
            System.out.println("输出队列已满，添加失败");
        } else {
            // 把打印数据添加到队列里，已保存数据的数量加1。
            printData[dataNum++] = msg;
        }
    }
}
OutputFactory.java
public class OutputFactory {

    public Output getOutput() {
        // 通过修改下面一行代码可以控制系统到底使用Output的哪个实现类。
        return new Printer();
    }

}

4. 代码分析

Computer——场景类，模拟具体实现场景
Output——接口，抽象输出设备的共有属性和方法
OutputFactory——工厂类，完成 Output 实现类的创建过程，实现 Computer 类与 Output 实现类的解耦
Printer——Output 实现类，实现输出设备的具体属性和方法

5. 系统重构

要求：使用 BetterPrinter 类来代替 Printer 类
解决：只需让 BetterPrinter 类实现 Output 接口，并改写 OutputFactory 类的 getOutput() 方法即可

6. 系统重构源码

Computer.java
public class Computer {

    private Output out;

    // 通过构造器注入方式实现 Computer 类与 Output 接口的耦合
    public Computer(Output out) {
        this.out = out;
    }

    // 定义一个模拟获取字符串输入的方法
    public void keyIn(String msg) {
        out.getData(msg);
    }

    // 定义一个模拟打印的方法
    public void print() {
        out.out();
    }

    public static void main(String[] args) {

        // 创建OutputFactory
        OutputFactory of = new OutputFactory();
        // 将Output对象传入，创建Computer对象
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();

    }
}
Output.java
public interface Output {

    // 接口里定义的属性只能是常量
    public static final int MAX_CACHE_LINE = 50;

    // 接口里定义的只能是public的抽象实例方法
    public void out();

    public void getData(String msg);
}
BetterPrinter.java
public class BetterPrinter implements Output {

    private String[] printData = new String[MAX_CACHE_LINE * 2];

    // 用以记录当前需打印的作业数
    private int dataNum = 0;

    public void out() {
        // 只要还有作业，继续打印
        while (dataNum > 0) {
            System.out.println("高速打印机正在打印：" + printData[0]);
            // 把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

    public void getData(String msg) {
        if (dataNum >= MAX_CACHE_LINE * 2) {
            System.out.println("输出队列已满，添加失败");
        } else {
            // 把打印数据添加到队列里，已保存数据的数量加1。
            printData[dataNum++] = msg;
        }
    }
}
OutputFactory.java
public class OutputFactory {

    public Output getOutput() {
        // 通过修改下面一行代码可以控制系统到底使用Output的哪个实现类。
        return new Printer();
    }

}

7. 系统重构源码分析

Computer——场景类，模拟具体实现场景
Output——接口，抽象输出设备的共有属性和方法
OutputFactory——工厂类，完成 Output 实现类的创建过程，实现 Computer 类与 Output 实现类的解耦
BetterPrinter——Output 实现类，实现输出设备的具体属性和方法，用于替换系统中的 Printer 对象

8. 代码问题整理

①java.lang.System 类 public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 方法的作用是什么？

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
作用：从源数组 src 中复制一个数组到目标数组 dest 中。原数组起始位置为 srcPos，目标数组起始位置为 destPos，复制长度为 length

②Computer.java类中问题 1 ？

public class Computer {

/********************************************************************/
//1. 以下代码是否可以重写写入一个新的类中？
    private Output out;

    // 通过构造器注入方式实现 Computer 类与 Output 接口的耦合
    public Computer(Output out) {
        this.out = out;
    }

    // 定义一个模拟获取字符串输入的方法
    public void keyIn(String msg) {
        out.getData(msg);
    }

    // 定义一个模拟打印的方法
    public void print() {
        out.out();
    }

/********************************************************************/

    public static void main(String[] args) {

        // 创建OutputFactory
        OutputFactory of = new OutputFactory();
        // 将Output对象传入，创建Computer对象
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();

    }
}

该问题的解决方案如下：

Client.java
/**
 * 场景类——用于测试简单工厂模式
 */
public class Client {

    public static void main(String[] args) {

        // 获取OutputFactory
        OutputFactory of = new OutputFactory();

        // 获取Output
        Output output = of.getOutput();
        System.out.println("打印机" + output.getClass().getName() + "正在工作");

        // 将Output对象传入，创建Computer对象
        Computer c = new PersonComputer(output);

        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.keyIn("设计模式之禅");
        c.print();

    }
}
Computer.java

public interface Computer {

    public void keyIn(String msg);

    public void print();

}
PersonComputer.java
/**
 * 调用者
 *
 */
public class PersonComputer implements Computer {

    private Output out;

    // 通过构造器注入方式实现 Computer 类与 Output 接口的耦合
    public PersonComputer(Output out) {
        this.out = out;
    }

    // 定义一个模拟获取字符串输入的方法
    public void keyIn(String msg) {
        out.getData(msg);
    }

    // 定义一个模拟打印的方法
    public void print() {
        out.out();
    }
}
Output.java
/**
 * 输出接口——定义输出设备的通用属性和方法
 *
 */
public interface Output {

    // 接口里定义的属性只能是常量
    public static final int MAX_CACHE_LINE = 50;

    // 接口里定义的只能是public的抽象实例方法
    public void out();

    public void getData(String msg);
}

Printer.java

/**
 * 被调用者
 * 
 * 接口的实现类——接口中定义的方法和属性的具体实现
 *
 */
public class Printer implements Output {

    private String[] printData = new String[MAX_CACHE_LINE];

    // 用以记录当前需打印的作业数
    private int dataNum = 0;

    public void out() {
        // 只要还有作业，继续打印
        while (dataNum > 0) {
            System.out.println("打印机打印：" + printData[0]);
            // 把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

    public void getData(String msg) {
        if (dataNum >= MAX_CACHE_LINE) {
            System.out.println("输出队列已满，添加失败");
        } else {
            // 把打印数据添加到队列里，已保存数据的数量加1。
            printData[dataNum++] = msg;
        }
    }
}

OutputFactory.java

/**
 * 工厂——实现解耦
 *
 */
public class OutputFactory {

    public Output getOutput() {
        // 通过修改下面一行代码可以控制系统到底使用Output的哪个实现类。
        return new Printer();
//      return new BetterPrinter();
    }

}

【相关问题】

1. 简单工厂模式使用的三个要求：

① 调用者面向被依赖对象的接口编程；
② 将被依赖对象的创建交给接口完成；
③ 调用者通过工厂来获得被依赖组件；

2. 简单工厂模式的优点有哪些？

① 让对象的调用者和对象的创建过程分离，当对象调用者需要对象时，直接从工厂获取；
② 避免了对象的调用者与对象的实现类以硬编码的方式耦合，以提高系统的可维护性、可扩展性；

3. 简单工厂模式的缺点有哪些？

当产品修改时，工厂类必须做出相应的修改

Impr4L
关注
专栏目录
软件设计---简单工厂模式（Java）
云卷云舒
04-13 359
创建型模式 对类的实例化进程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。 创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。 简单工厂模式 模式动机 考虑一个简单的软件应用场景，一个软件系统可以提供多个外观不同的按钮...
简单工厂模式（Simple Factory Pattern）
天天开心鸭！
03-25 568
简单工厂模式动机概述代码实现模式分析结构图结构分析使用场景总结 动机 为什么会有简单工厂这个模式的呢？这概念是怎么引入的呢？没有简单工厂之前是如何开发的？遇到的主要问题是什么？ 我们来考虑一个简单的软件应用场景，一个计算器系统可以提供多个运算（如加、减、乘、除等）， 这些运算功能都源自同一个类，不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的运算，如果我们希望在使用这些运算时，不...
【设计模式】——简单工厂模式（Simple Factory Pattern）
最新发布
J^T的博客
08-05 689
简单工厂模式又称为静态工厂方法模式，它定义了一个工厂类，这个类根据传入的参数不同返回不同类的实例。这些实例通常都具有共同的父类或接口。简单工厂模式的核心在于将对象的创建逻辑封装在工厂类中，客户端通过调用工厂类的静态方法来获取所需的对象，而无需直接实例化具体产品类。
简单工厂模式 (Simple Factory Pattern)
NRatel
08-22 331
本文现已搬迁至： https://blog.csdn.net/NRatel/article/details/84253549 此博客废弃，我的新CSDN账号：https://blog.csdn.net/NRatel/
简单工厂模式_简单工厂模式_
10-02
简单工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪一个类。这种模式使得代码能够将实例化的责任封装起来，使得客户端代码无需关心具体的对象实现，只需要知道一个公共接口即可...
js简单工厂模式用法实例
10-24
简单工厂模式是软件设计领域中一种常见的创建型设计模式，它提供了一种创建对象的最佳方式。在JavaScript这种基于原型继承的动态语言中，简单工厂模式同样有着广泛的应用。简单工厂模式的核心思想是将对象的创建与...
简单工厂模式uml类图
03-07
java设计模式 简单工厂模式uml类图，一张图就让你秒懂简单工厂模式
简单工厂模式-Simple Factory
金鳞踏雨
04-16 307
引入案例——咖啡店点餐系统： 要求： 设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。 UML类图如下： Code如下： （1）Main方法 package 简单工场; public class coffeeTest { public static void main(String[] args) { //1.创建
简单工厂模式（Simple Factory）
傅红雪的专栏
04-10 747
简单工厂（Simple Factory）模式：又称静态工厂方法（Static Factory Method Pattern）模式。它是类的创建模式。由一个工厂类根据传入的参数决定要创建哪一种产品类的实现。简单工厂模式涉及到三个角色： 工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，往往由一个具体的Java类
Java简单工厂模式详解与应用
"Java简单工厂模式是编程中常见的一种设计模式，它虽然不是严格意义上的设计模式，但在实际应用中十分普遍。简单工厂模式的核心思想是将对象的创建过程封装起来，使得客户端无需关心具体的实现细节，只需通过工厂来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值