How to create Factory Pattern in Java

The Factory Design Pattern is a creational pattern and provides a better way of creating an object without specifying the exact class that need to be created. The object is created without exposing the creation logic to the client and will refer to the new object using a interface.

Example

A good example where the Factory Design Pattern can be used if is needed to implement an generic solution for creating a database table regardless the database engine.

The factory design pattern relies on inheritance, as the object creation is delegated to the sub-classes that implement the factory method to create objects.

For this, will need an interface to define the behaviour for all classes. Will take a simple example with only one method.

package com.admfactory.factory;

public interface Table {
    public boolean create();
}

And some concrete classes to implement the interface. These classes will implement the create method with a simple console output, just for testing.

For example will choose a few of the main database engines available:

• MSSQL
• MySQL
• Oracle
• PostgreeSQL

package com.admfactory.factory;

public class MSSQLTable implements Table {

    @Override
    public boolean create() {
	System.out.println("MSSQLTable::create() was called.");
	return true;
    }
}

package com.admfactory.factory;

public class MySQLTable implements Table {

    @Override
    public boolean create() {
	System.out.println("MySQLTable::create() was called.");
	return true;
    }
}

package com.admfactory.factory;

public class OracleTable implements Table {

    @Override
    public boolean create() {
	System.out.println("OracleTable::create() was called.");
	return true;
    }
}

package com.admfactory.factory;

public class PostgreSQLTable implements Table {

    @Override
    public boolean create() {
	System.out.println("PostgreSQLTable::create() was called.");
	return true;
    }
}

For database type can be used an enumeration, but in the same way can be used any other type.

package com.admfactory.factory;

public enum DatabaseType {
    MySQL, MSSQL, Oracle, PostgreSQL
}

package com.admfactory.factory;

public class TableFactory {
    public Table getTable(DatabaseType type) {
	if (type == DatabaseType.MySQL) {
	    return new MySQLTable();
	} else if (type == DatabaseType.MSSQL) {
	    return new MSSQLTable();
	} else if (type == DatabaseType.PostgreSQL) {
	    return new PostgreSQLTable();
	} else if (type == DatabaseType.Oracle) {
	    return new OracleTable();
	} else {
	    return null;
	}
    }
}

Usage

Here is a simple example how the factory class is being used.

package com.admfactory.factory;

public class FactoryExample {
    public static void main(String[] args) {
	System.out.println("Factory Design Pattern Example");
	System.out.println();
	TableFactory factory = new TableFactory();

	Table table1 = factory.getTable(DatabaseType.MSSQL);
	table1.create();

	Table table2 = factory.getTable(DatabaseType.MySQL);
	table2.create();

	Table table3 = factory.getTable(DatabaseType.PostgreSQL);

	table3.create();

	Table table4 = factory.getTable(DatabaseType.Oracle);

	table4.create();
    }
}

Output

In the console output can be observed that even if all 4 objects type is Table the factory class will return the specific implementation type based on the parameter.

Factory Design Pattern Example

MSSQLTable::create() was called.
MySQLTable::create() was called.
PostgreSQLTable::create() was called.
OracleTable::create() was called.

References

• Factory Method Pattern