A constructor always returns a brand-new instance of its exact class, with a name fixed to the class. A factory method is a regular (often static) method that creates objects — giving you freedom over naming, which subtype to return, and whether to create a new object at all.
public class Color {
private final int r, g, b;
private Color(int r, int g, int b) { this.r=r; this.g=g; this.b=b; }
// Named factories: clearer intent than overloaded constructors
public static Color fromRgb(int r, int g, int b) { return new Color(r,g,b); }
public static Color fromHex(String hex) { /* parse */ return new Color(0,0,0); }
// Can return a CACHED instance instead of always allocating
private static final Color BLACK = new Color(0,0,0);
public static Color black() { return BLACK; } // no 'new' every call
}
| Constructor | Factory method | |
|---|---|---|
| Name | Fixed to class | Descriptive (fromHex) |
| Return type | Exactly this class | Any subtype / interface |
| Identity | Always new | May cache/pool/reuse |
| Can fail gracefully | Throws | Can return null/Optional |
Optional<User> u = User.tryParse(json); // a constructor can't return Optional
Factories add indirection and can hide what's really constructed. Use a plain constructor for simple value creation; reach for a factory when you need naming, polymorphic returns, or instance control.
Factory methods decouple callers from concrete classes — you can return a different implementation or a cached instance without changing call sites.
They also make APIs clearer: Color.fromHex("#fff") reads better than a constructor overload, and named factories sidestep the ambiguity of multiple same-typed constructors.