Abstract Factory or Factory Method?

DZone 's Guide to

Abstract Factory or Factory Method?

Compare the Factory Method Pattern and Abstract Factory Pattern: what they are, and when they should be used.

· Java Zone ·
Free Resource

Today I would like to tell you about Factory Method Pattern and Abstract Factory Pattern. The purpose of the article is to help you recognize places where one of them should be used. 

What Will We Talk About?

Those patterns are one of the Creational Patterns and as the name suggest their main responsibility is creating the objects. However, we are using them in different situations.

In Wikipedia you can find the following definitions:

[...] the Factory Method Pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created.
The essence of the Abstract Factory Pattern is to "Provide an interface for creating families of related or dependent objects without specifying their concrete classes.".
Ok, when we are familiar with the theory, we can look how it works in practice.

Factory Method as a Named Constructor

Factory Method Pattern can help you make your code more readable.

Take a look at the class Person:

public class Person {
 public Person(Person mum, Person dad) {
 // some code

 public Person() {
 // some code
Is it clear for you why we have got two constructors and why both of them create a valid object?

Would it be more obvious if the code looked like the one below?

public class Person {
 public static Person withParents(Person mum, Person dad) {
 // some code

 public static Person anOrphan() {
 // some code

 private Person() {}
Is it better?

I believe that you saw classes with more constructors. Was it always easy to find out what all the differences between created objects were? Don’t you think that using Named Constructors is the solution that can save the time of a person who will have to work with the code?

Stay Focused on Interface

It’s good practice to focus on generalization rather than on specification. Factory Method Pattern can help you with that.

If you have a group of classes that implements the same interface, you can create them with factory methods, not with the new keyword.
Thanks to this, only the interface and class responsible for creation would be published:

public interface Currency {}

class Zloty implements Currency {}
class Euro implements Currency {}
class Dolar implements Currency {}

public class Currencies {
 public static Currency dollar() {
 return new Dollar();

 public static Currency euro() {
 return new Euro();

 public static Currency zloty() {
 return new Zloty();
In the given example only the Currency interface and Currencies class will be used outside the package. This gives you much more flexibility in case of any change. The only thing you need to worry about is the API of Currency and Currencies classes. Everything else, from the perspective of the developer who will use this code, is irrelevant.

Give a Choice

If there are groups of objects organized around one concept, but the creation of the specific instances depends on chosen option it can be worth considering using the Abstract Factory Pattern.

In the example below we give a choice to specify components’ theme. Depending on the choice, we are using a specific factory to create the needed objects, as follows:

public interface OSComponents {
 Window aWindow();
 Menu aMenu();
 Panel aPanel();

public interface Window {}
public interface Panel {}
public interface Menu {}

public class UnixComponents implements OSComponents {
 public Window aWindow() {
 return new UnixWindow();

 public Menu aMenu() {
 return new UnixMenu();

 public Panel aPanel() {
 return new UnixPanel();

public class WindowsComponents implements OSComponents {
 // code

public class iOSComponents implements OSComponents {
 // code
Now we can focus only on the interface provided by OSComponents interface. We don’t care at all about any specific implementation.


You should use Abstract Factory Pattern where the creation of specific objects depends on a choice. You are creating a required factory object and passing it further. The code that manipulates on it is interested only in interfaces.

Factory Method Pattern should be used when you want to explain what logic stands behind creating an object in given state (Named Constructor) or when you want to publish only an interface, not an entire group of classes that implements it.

Hopefully, this article will help you with making a decision when you should use a particular solution.

But maybe this is not all? If you noticed something that I missed, please share it by posting your comment below.

dependency injection, java, spring

Published at DZone with permission of Sebastian Malaca , DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}