All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Singleton pattern, and how would you implement a thread-safe Singleton in Java? How does the Builder pattern solve the "telescoping constructor" problem, and how would you implement it for a class with many optional parameters? What is the Strategy pattern, and how do Java 8's functional interfaces and lambdas make implementing it significantly more concise than the traditional interface-plus-implementation-classes approach? What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself?
Advertisement
Java › Design Patterns in Java

What is the Factory Method pattern's simplest form -- a basic static factory returning different subtype instances based on input -- and why might you prefer it over exposing constructors directly?

Beginner

Answer

A simple factory encapsulates object creation logic behind a single method (often static) that decides which concrete subtype to instantiate based on input parameters, hiding the specific subclasses entirely from calling code -- this is useful when the calling code shouldn't need to know or care about the specific implementation class being used, only the common interface/supertype, and centralizes creation logic in one place rather than scattering constructor calls (and the subtype-selection logic they'd otherwise require) throughout the codebase.
public interface Shape { double area(); }
class Circle implements Shape { /* ... */ }
class Square implements Shape { /* ... */ }

public class ShapeFactory {
    public static Shape create(String type, double size) {
        return switch (type) {
            case "circle" -> new Circle(size);
            case "square" -> new Square(size);
            default -> throw new IllegalArgumentException("Unknown shape: " + type);
        };
    }
}
Real-world example A drawing application reads shape type names from a configuration file and uses a simple ShapeFactory.create() method to instantiate the correct Shape subtype, keeping the mapping between configuration strings and concrete classes centralized in one place rather than scattered across the codebase wherever a shape needs to be created.

Common follow-ups: How does this simple factory differ from the true Gang-of-Four Factory Method pattern involving subclass-overridden creation?;What happens to this design as the number of supported shape types grows very large?

Interfaces & Abstract Classes;OOP & Classes
All 15 Design Patterns in Java questions