1. Overview

1.概述

In this tutorial, we’ll learn how to implement the factory pattern with generics in Java.

在本教程中，我们将学习如何在Java中用泛型实现工厂模式。

2. What Is Factory Pattern?

2.什么是工厂模式？

In object-oriented programming, the factory pattern is a creational design pattern that is responsible for creating objects when it’s called.

在面向对象的编程中，工厂模式是一种creational设计模式，它负责在被调用时创建对象。

A factory is a class that creates objects of a prototype class, aka interface, from a method call:

工厂是一个可以通过方法调用创建原型类（又称接口）对象的类：。

The factory pattern is good when we want to create objects of a common interface while hiding the creation logic from the user.

当我们想创建一个通用接口的对象，同时向用户隐藏创建逻辑时，工厂模式就很好。

3. How Is It Implemented?

3.它是如何实施的？

Now let’s learn how to implement it. First, let’s take a look at the class diagram:

现在让我们来学习如何实现它。首先，让我们看一下类图。

Now let’s implement each class in the diagram.

现在让我们来实现图中的每个类。

3.1. Implementing the Notifier Interface

3.1.实现Notifier接口

The Notifier interface is a prototype, and other notifier classes implement it:

Notifier接口是一个原型，其他通知器类实现了它。

public interface Notifier<T> {
    void notify(T obj);
}

As we can see, the Notifier class is a generic class that has one method named notify.

我们可以看到，Notifier类是一个通用类，有一个名为notify的方法。

3.2. Implementing the Notifier Classes

3.2.实现Notifier类

Now let’s implement the two other notifier classes:

现在让我们来实现另外两个通知器类。

public class StringNotifier implements Notifier<String> {

    @Override
    public void notify(String str) {
        System.out.println("Notifying: " + str);
    }
}

public class DateNotifier implements Notifier<Date> {

    @Override
    public void notify(Date date) {
        System.out.println("Notifying: " + date);
    }
}

Now we have two classes that use the Notifier interface – one that will output a simple text and one that will post a date.

现在我们有两个使用Notifier接口的类–一个将输出一个简单的文本，一个将发布一个日期。

3.3. Implementing the Factory

3.3.实现工厂

The factory class generates a notifier instance each time its only method, getNotifier(), is called:

工厂类在每次调用其唯一的方法getNotifier()时都会生成一个通知器实例。

public class NotifierFactory {

    public <T> Notifier<T> getNotifier(Class<T> c) {
        if (c == String.class) {
            return Record.STRING.make();
        }
        if (c == Date.class) {
            return Record.DATE.make();
        }
        return null;
    }

}

In the above code, Record is an enum with two constants named STRING and DATE.

在上面的代码中，Record是一个枚举，有两个名为STRING和DATE的常数。

3.4. Implementing the Record

3.4.实现Record

The Record enum keeps the record of valid notifier classes and creates an instance each time the factory class calls it:

Record枚举保存有效通知器类的记录，并在工厂类每次调用它时创建一个实例。

public enum Record {
    STRING {
        @Override
        public Notifier<String> make() {
            return new StringNotifier();
        }
    },
    DATE {
        @Override
        public Notifier<Date> make() {
            return new DateNotifier();
        }
    };

    public abstract <T> Notifier<T> make();
}

We’ve successfully implemented the factory pattern.

我们已经成功实现了工厂模式。

4. Using the Factory

4.使用工厂

Let’s use the factory in our Main class:

让我们在我们的Main类中使用该工厂。

public static void main(String[] args) {
    NotifierFactory factory = new NotifierFactory();
    Notifier<String> stringNotifier = factory.getNotifier(String.class);
    Notifier<Date> dateNotifier = factory.getNotifier(Date.class);

    stringNotifier.notify("Hello world!");
    dateNotifier.notify(new Date());
}

Now we should compile and run our code:

现在我们应该编译并运行我们的代码。

$ javac Main.java
$ java Main
Notifying: Hello world!
Notifying: Wed Oct 19 17:36:38 TRT 2022

As we can see, the factory has successfully created two notifier instances of the appropriate type.

我们可以看到，工厂已经成功创建了两个适当类型的通知器实例。

5. Summary

5.摘要

In this article, we learned how to implement and use the factory pattern in Java.

在这篇文章中，我们学习了如何在Java中实现和使用工厂模式。

As always, the source code is available over on GitHub.

像往常一样，源代码可在GitHub上获得。