Home Design Pattern How to Easily use Factory Design Pattern in Java

How to Easily use Factory Design Pattern in Java

by Imran Shaikh
How to Easily use Factory Design Pattern in Java

Hey, Tea Lovers! Let me continue our design pattern series by adding this post. The Factory Design Pattern or Factory Method Design Pattern. It is one of the widely used and easy-to-understand Design patterns. It’s an effortless yet effective way of hiding object creation complexity. That’s why it is under the creation pattern category. So let’s jump right into it.

You can follow me on social media via @coderstea on TwitterLinkedinFacebook, or Instagram. We also share high-quality videos about programming on our Youtube channel. You can also publish your post on CodersTea, just share your thought on Contact Us or let us know in the comments.

Prerequisite to knowing Factory Design Pattern

Before understanding what a factory design pattern is, you need to understand what superclass and subclass are. I am pretty sure you are aware of this detail, if not, the following section describes it in brief. if you already know it, you can skip to this part

SuperClass VS SubClass / Parent VS Child Classes

A superclass is a class or interface that is defined as a base class. And subclasses are the one that extends or implements it (superclass). For example, Student is an interface (or you can make it class, up to you). Now there can be multiple types of students. No, I am not talking about A+ or F students, I don’t want to make fun of myself here.

Instead, let’s say it’s based on different courses. Such as FinanceStudent, ComputerStudent or an ArtStudent. These are different classes, but all these are of type students, right? So we will implement the Student interface for each student type. As soon as you implement or extend any class, the current class becomes the subclass of it. In our case, All these students, FinanceStudent, ComputerStudent and ArtStudent are subclasses of Student. And Student is the superclass or base class (yes, even though it’s an interface) of these subclasses.

interface Student {
  String getName();

class FinanceStudent implements Student {
  public String getName(){
    // do something
// same for ComputerStudent and  ArtStudent

The Challenge

In our little example above, we have many student classes, and many more to come. Usually, we will create each student separately like the following.

Student st = new FinanceStudent("Student 1");
Student st2 = new ArtStudent("Stuent 2");
Student stN = new NthCoursedStudent("Student Nth");

In the above example, every time you needed any student, you needed to explicitly select the appropriate student type and call the new keyword. Now the problem here is that let’s say for the Art Student we want to pass some default value every time we create the object. Or we want to validate the provided string to the Student class. This will be very difficult to handle as the object creation is scattered through the code. And it will be more tedious because, for each student type, you need to add the validation logic. So how would we solve this challenge?

You must be thinking, What if we can collect all these student creation logic into a single class or function? Interesting point and what you are thinking is basically called the Factory Design Pattern. Let’s deep dive into it.

What is Factory Design Pattern

Simply put, It is a way of putting the object creation logic (similar type) into a single class or function. Similar to a factory. You just ask the factory to build a certain product. The factory takes care of the product building based on your requirement and gives you the final product. You don’t have to worry about what’s happening inside the factory.

In our previous example, we created the Student classes Nth time. Let us apply the Factory Design Pattern (in a very simple way) to it.

Creating a Factory Design Class

Keep in mind, that I am creating a very simple one, you may make it more tailored to your need.

Let us start with the Factory Base Class. And inside that create a function called createStudent. And make it public and static for easy access. We will worry about how to create it later. Your code now may look like the following.

class StudentFactory {
    public static Student createStudent(){
        // TODO
       return null;

Now, how to determine which type of Student it needs to create? For that, we can use String or can use an enum for more maintainable code.

enum StudentTypes {

The next step is to get this enum as a parameter along with the Student name in the createStudent method. After that, we will simply do an if-else or switch condition. And if you are using the latest java, you can use this: Java Switch Statement is now more Powerful | Java 18. Your createStudent will now look like this.

public static Student createStudent(StudentTypes studentType,
                                    String name) {
    System.out.printf("Creating %s student object with name %s \n"
            , studentType, name);
    switch (studentType) {
        case FINANCE:
            return new FinanceStudent(name);
        case ART:
            return new ArtStudent(name);
        case COMPUTER:
            return new ComputerStudent(name);
            // returning null is not recommended
            return new ComputerStudent(name);

And that’s it, this is your factory design pattern. now you simply have to call the createStudent function with the appropriate type enum and voila, and you will get that student object. Now you must be wondering whats the advantages of it, right? Let’s take one of the scenarios I mentioned in the challenge section.

Benefits of Factory Design Pattern

Let us say we want to validate the provided name. Check if it is null or not. If null throw an exception. Before FDP, we would have to check the name independently beforeeach creation logic. which would have been a redundant task. But now with the FDP function we created, we have to write and call the logic only once. We can write a null check just before the switch statement. Or in case you have a long logic for validation, just create a separate function and call it before the switch statement, easy.

if(name == null){
    throw new RuntimeException("name is null");

Example of Factory Design Pattern

There are many examples of this pattern. Many could be found in the java library itself. For a custom practical example, you can look at my hack on multiple database pooling. The post is How to create a Multi-Database Pool in HikariCP.


That’s it for this post. Hope you have understood the basics of the Factory Design Pattern. It’s a very easy and simple design pattern out there. Please check out the How to create a Multi-Database Pool in HikariCP post for a practical example of this pattern. You can see the full code on GitHub.

See you in the next post. HAKUNA MATATA!!!

Notify of
Inline Feedbacks
View all comments

This website uses cookies to improve your experience. We'll assume you're ok with this, but you can opt-out if you wish. Accept Read More