Factory Design Pattern in Java with Example

Table Of Content

• Polygon Interface
• Implementation of the Factory Pattern
• Factory Design Pattern in Java with Example
• Structural Software Design Patterns in Java
• What kind of problem does the factory design pattern solve? Why use the factory design pattern in Java?
• My Udemy Course - Testing Spring Boot Application with JUnit and Mockito

The subclass then inherits most of the code from the base class, but, thanks to the factory method, can render Windows-looking buttons on the screen. The code that uses the factory method (often called the client code) doesn’t see a difference between the actual products returned by various subclasses. The client knows that all transport objects are supposed to have the deliver method, but exactly how it works isn’t important to the client. It also prevents us in making changes to car making process because the code is not centralized, and making changes in all composing classes seems not feasible.

GoF Design Patterns Using Java (Part 1) - DZone

GoF Design Patterns Using Java (Part .

Posted: Thu, 02 Feb 2017 08:00:00 GMT [source]

Polygon Interface

It involves defining an interface or abstract class for creating objects (the factory) and allowing subclasses to alter the type of objects that will be created. This pattern decouples object creation from the client code, promoting flexibility, maintainability, and scalability. Notice what we did there, we moved out the createDrink logic, which was involved in instantiating new objects to a separate class. The method that implements the logic of creating objects of concrete classes has a special name, factory method.

Implementation of the Factory Pattern

Adding a new class to the program isn’t that simple if the rest of the code is already coupled to existing classes. CarType will hold the types of car and will provide car types to all other classes. Sooner or later, a desktop program, mobile app, or some other type of software will inevitably become complex and start exhibiting certain kinds of problems. These problems are typically related to the complexity of our codebase, non-modularity, inability to separate certain parts from each other, etc. As you can see from my driver class, I create an instance of each type of dog (small, big, and working).

Factory Design Pattern in Java with Example

If we want to bring in a new drink, the only place that needs to change is the Drink Factory class. Thus, restricting us to make changes to only one class and easily extend the code to incorporate a new drink. We just need to create a new drink class that implements the Drink abstract class. We can think of the factory method pattern in terms of creator and product classes. In our case, drink cafe is an abstract creator class that defines an abstract factory that is implemented by the subclasses to produce drinks.

Any changes that may occur inside any subclass will eventually force us to make changes to the drinkCafe class as well. It should be pretty clear that reducing dependencies to concrete classes in our code should be considered a  “good thing”. Base dialog works with products using their common interface, that’s why its code remains functional after all changes. Factory pattern is most suitable where there is some complex object creation steps are involved. To ensure that these steps are centralized and not exposed to composing classes, factory pattern should be used.

Structural Software Design Patterns in Java

One of the goals of software development is to design products in such a way that the software can incorporate changes easily. The de facto standard in today's date is to follow the classic design patterns. Whatever modifications are needed can be done in a shorter span of time than it really takes. If a software development team writes code that needs a lot of modifications to add simple extensions to the product, they are not following the best practices.

What kind of problem does the factory design pattern solve? Why use the factory design pattern in Java?

Here is a Factory Method pattern to convert currency values between Indian Rupees (INR), US Dollars (USD), and Great British Pounds (GBP). Now that we have super classes and sub-classes ready, we can write our factory class. Java factory design pattern is one of the most used design pattern. However, this will lead to the create(AccountType type) method becoming increasingly bloated. The first strength of the Factory pattern that we can see is that it centralizes the creation of objects in one place.

They represent solutions to some commonly occurring problems in the programming industry, which have intuitive solutions. To master the Factory Design Pattern in Java, it's beneficial to collaborate with seasoned professionals. Saigon Technology, with its expertise in Java development, provides robust solutions that can help streamline your software development process. Based on the diagram above, let's go through the implementation of this design pattern together.

The Factory Method Pattern

I hope, I have included enough information in this Java factory pattern example to make this post informative. So far we have design the classes need to be designed for making a CarFactory. This goes on as you add more related variations of a logical collection - all spaceships for instance.

The Best Engineering Mods For Minecraft - TheGamer

The Best Engineering Mods For Minecraft.

Posted: Sun, 03 Sep 2023 07:00:00 GMT [source]

For a start, classes in java or any other object-oriented programming language are generally written in a way that leads to coupling problems, unless design patterns are used. Subclasses get highly dependent on each other when the code gets larger and larger and that is where the real problem begins. This cannot go on forever and we need some elegant way to avoid such a situation. Factory Method is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. The Factory Design Pattern is a creational design pattern that provides a simple and flexible way to create objects, decoupling the process of object creation from the client code.

In my previous post, “Singleton design pattern in java“, we discussed various ways to create an instance of a class such that there can not exist another instance of same class in same JVM. It's a misconception that design patterns are holy solutions to all problems. Design patterns are techniques to help mitigate some common problems, invented by people who have solved these problems numerous times. This is an interface or an abstract class that declares the method for creating objects. In the example, CurrencyFactory is the factory interface with the method createCurrency().

Let's expand our code example to understand what the Factory method pattern is. All factory design patterns encapsulate the creation of objects. The Factory Method Pattern extends this idea and encapsulates object creation by letting subclasses decide what objects to create.

Adding Ships into the app would require making changes to the entire codebase. Moreover, if later you decide to add another type of transportation to the app, you will probably need to make all of these changes again. If you still have some doubt on abstract factory design pattern in Java, please leave a comment. The client can then create objects through a common interface which simplifies the process. Let’s consider the above-mentioned diagram for implementing a factory design pattern.

Secondly, this pattern minimizes the dependency between classes. For example, in the future, there might be new types of accounts such as Credit, Debit, etc. At that time, we only need to create additional subclasses that extend BankAccount and add them to the factory method.

By writing code that uses this interface, we decouple our code from the actual factory that creates the products. A variety of products can be all the different types of drinks, and decorative items or ingredients for the Drink class. Now you have got the better of the factory design pattern example in java, you can now understand the factory method pattern definition. As with every factory, the Factory Method Pattern gives us a way to encapsulate the instantiations of concrete types. The Factory Method Pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory design pattern provides a way to create objects without specifying their exact class at compile time.