Factory Method Pattern in Java: Implementation Guide
Explore the implementation of the Factory Method pattern in Java, enhancing flexibility and maintainability in object creation through inheritance and polymorphism.
2.2.2 Implementing Factory Methods in Java
The Factory Method pattern 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. This pattern promotes loose coupling by eliminating the need to instantiate objects directly, thus adhering to the principle of programming to an interface rather than an implementation.
Understanding the Factory Method Pattern
Before diving into the implementation, let’s break down the key components of the Factory Method pattern:
- Product Interface/Abstract Class: Defines the interface or abstract class that all concrete products will implement.
- Concrete Products: These are the classes that implement the Product interface.
- Creator Class: Contains the factory method that returns a Product object. This method is usually abstract.
- Concrete Creators: Subclasses of the Creator class that implement the factory method to produce specific products.
Implementing the Factory Method Pattern in Java
Let’s explore a step-by-step implementation of the Factory Method pattern in Java through a practical example. We’ll create a simple application that simulates a document editor supporting different document types (e.g., Word, PDF).
Step 1: Define the Product Interface
First, we define the Document interface that all document types will implement.
// Product Interface
public interface Document {
void open();
void save();
void close();
}
Step 2: Create Concrete Products
Next, we implement concrete classes for each document type, such as WordDocument and PDFDocument.
// Concrete Product: WordDocument
public class WordDocument implements Document {
@Override
public void open() {
System.out.println("Opening Word document...");
}
@Override
public void save() {
System.out.println("Saving Word document...");
}
@Override
public void close() {
System.out.println("Closing Word document...");
}
}
// Concrete Product: PDFDocument
public class PDFDocument implements Document {
@Override
public void open() {
System.out.println("Opening PDF document...");
}
@Override
public void save() {
System.out.println("Saving PDF document...");
}
@Override
public void close() {
System.out.println("Closing PDF document...");
}
}
Step 3: Define the Creator Class
The Application class acts as the creator, declaring the factory method createDocument().
// Creator Class
public abstract class Application {
// Factory Method
protected abstract Document createDocument();
// Other methods that use the factory method
public void newDocument() {
Document doc = createDocument();
doc.open();
doc.save();
doc.close();
}
}
Step 4: Implement Concrete Creators
Concrete creator classes override the factory method to produce specific products.
// Concrete Creator: WordApplication
public class WordApplication extends Application {
@Override
protected Document createDocument() {
return new WordDocument();
}
}
// Concrete Creator: PDFApplication
public class PDFApplication extends Application {
@Override
protected Document createDocument() {
return new PDFDocument();
}
}
Step 5: Client Interaction
The client interacts with the creator class, using the factory method to create and manipulate products.
public class Client {
public static void main(String[] args) {
Application wordApp = new WordApplication();
wordApp.newDocument();
Application pdfApp = new PDFApplication();
pdfApp.newDocument();
}
}
How the Factory Method Pattern Promotes Flexibility
The Factory Method pattern enhances flexibility in object creation by allowing subclasses to decide which class to instantiate. This approach follows the Open/Closed Principle, enabling the system to be open for extension but closed for modification.
Inheritance and Polymorphism
The pattern leverages inheritance to provide a default implementation of the factory method in the creator class. Polymorphism is used to allow concrete creators to override this method, providing specific implementations for creating products.
Handling Parameters in Factory Methods
If the factory method requires parameters to determine the type of product to create, you can pass these parameters to the method. This approach allows for more dynamic product creation.
// Example of a parameterized factory method
public abstract class ParameterizedApplication {
protected abstract Document createDocument(String type);
public void newDocument(String type) {
Document doc = createDocument(type);
doc.open();
doc.save();
doc.close();
}
}
Examples in Java’s Standard Libraries
The Factory Method pattern is prevalent in Java’s standard libraries. For instance, the java.util.Calendar class uses a factory method to create calendar instances.
Calendar calendar = Calendar.getInstance();
Impact on Maintainability and Extensibility
By decoupling the instantiation process from the client, the Factory Method pattern improves maintainability and extensibility. New product types can be added with minimal changes to existing code, as only new concrete product and creator classes need to be introduced.
Encouraging Experimentation
To fully grasp the Factory Method pattern, experiment with different implementations. Try creating additional document types or modifying the factory method to accept parameters. This hands-on approach will deepen your understanding and reveal the pattern’s versatility.
Conclusion
The Factory Method pattern is a powerful tool in the Java developer’s toolkit, promoting flexibility and maintainability in object-oriented design. By understanding and implementing this pattern, you can create robust applications that are easy to extend and maintain.
