【设计模式系列】工厂模式

发表于

这是我参与11月更文挑战的第18天，活动详情查看：2021最后一次更文挑战

前言

面向对象设计模式分为三类：创建型、结构型和行为型，工厂设计模式是面向对象设计模式中的创建型设计模式之一。

创建型设计模式主要包括：

  • 单例模式
  • 工厂模式
  • 抽象工厂模式
  • 构建者模式
  • 原型模式

工厂设计模式主要用于某个超类有多个子类，需要通过输入条件创建其中一个子类对象时使用。我们可以在工厂类上应用Singleton模式，也可以将工厂方法定义为静态方法。

使用工厂设计模式会将对象的创建责任从调用方（客户端）转移到工厂类中。

工厂模式的结构

在工厂模式中，主要包含以下元素：

  • 超类（可以是一个接口，抽象类或一个具体的类）
  • 一个或多个子类
  • 工厂类

我们使用一个具体的例子来实现，比如根据条件创建计算机Computer，Computer是一个抽象概念，它有两个具体的实现PC机和笔记本Laptop。

首先定义出Computerc抽象类（也可以是一个接口）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
java复制代码/**
 * @author 小黑说Java
 * @ClassName Computer
 * @date 2021/11/17
 **/
public abstract class Computer {

    /**
     * 内存
     */
    public abstract String getRAM();

    /**
     * 硬盘
     */
    public abstract String getHDD();

    /**
     * CPU
     */
    public abstract String getCPU();

    @Override
    public String toString() {
        return "RAM= " + this.getRAM() + ", HDD=" + this.getHDD() + ", CPU=" + this.getCPU();
    }
}

然后定义PC和Laptop：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
java复制代码/**
 * @author 小黑说Java
 * @ClassName PC
 * @date 2021/11/17
 **/
public class PC extends Computer {

    private String ram;
    private String hdd;
    private String cpu;

    public PC(String ram, String hdd, String cpu) {
        this.ram = ram;
        this.hdd = hdd;
        this.cpu = cpu;
    }

    @Override
    public String getRAM() {
        return ram;
    }

    @Override
    public String getHDD() {
        return hdd;
    }

    @Override
    public String getCPU() {
        return cpu;
    }
}

代表笔记本电脑的Laptop:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
java复制代码/**
 * @author 小黑说Java
 * @ClassName Laptop
 * @date 2021/11/17
 **/
public class Laptop extends Computer{
    private String ram;
    private String hdd;
    private String cpu;
    
    public Laptop(String ram, String hdd, String cpu) {
        this.ram = ram;
        this.hdd = hdd;
        this.cpu = cpu;
    }
    @Override
    public String getRAM() {
        return ram;
    }

    @Override
    public String getHDD() {
        return hdd;
    }

    @Override
    public String getCPU() {
        return cpu;
    }
}

有了需要创建的实体类之后，我们接下来定义工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
java复制代码/**
 * @author 小黑说Java
 * @ClassName ComputerFactory
 * @date 2021/11/17
 **/
public class ComputerFactory {

    public static Computer getComputer(String type, String ram, String hdd, String cpu) {
        if ("PC".equalsIgnoreCase(type)) {
            return new PC(ram, hdd, cpu);
        }
        if ("Laptop".equalsIgnoreCase(type)) {
            return new Laptop(ram, hdd, cpu);
        }
        return null;
    }
}

这样对于客户端只需要根据需要的类型，调用工厂类的getComputer()方法获取想要的实例了。

接下来我们来通过一个简单的测试模拟工厂类的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
java复制代码/**
 * @author 小黑说Java
 * @ClassName FactoryTest
 * @date 2021/11/17
 **/
public class FactoryTest {

    public static void main(String[] args) {
        Computer pc = ComputerFactory.getComputer("PC", "16GB", "500GB", "2.4GHz");

        Computer laptop = ComputerFactory.getComputer("Laptop", "16GB", "500GB", "2.4GHz");

        System.out.println("PC:"+pc);
        System.out.println("laptop:"+laptop);
    }
}

运行结果：

工厂模式的优势

使用工厂模式具有以下优势：

  • 对具体要创建的类形成接口或抽象类，只需要提供方法定义，不用提供具体实现；
  • 从客户端移除了对实际类的实例化；
  • 代码健壮性更高，降低耦合，扩展性更好；

例如要修改PC的具体实现逻辑，只需要在PC类中修改，对于客户端来说透明。

JDK中的工厂模式

在JDK中有大量的工厂模式，比如：

  • java.util.Calendar类创建实例时，使用getInstance()，对于客户端来讲，不用关注Calendar创建的具体实现；
  • NumberFormat类创建实例时，也是使用getInstance()。

以上就是工厂模式的全部内容，工厂模式相对比较简单，下期内容是抽象工厂模式。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%