How do interfaces plus implementing classes realize the 'deferred instantiation' intent of Factory Method, and how does this support open/closed extension of an API over time?

## The pieces: interface, implementation, factory - An **interface** in Java is a pure contract: a set of method signatures with no (or default) bodies. It states *what* an object can do. - An **implementing class** (`class Foo implements Bar`) supplies the *how* for that contract. There can be many implementers of one interface. - A **factory method** is a method whose *declared return type is the interface* but which *internally constructs a concrete implementer*. Because the caller holds only the interface reference, it is **decoupled** from every concrete class. The phrase **deferred instantiation** captures this: "instantiation" is the act of creating an object with `new`; "deferred" means that act — and especially the *choice of which class to instantiate* — is moved out of the caller and postponed to the factory, which can make the decision later and from richer context (configuration, locale, registered providers). ## A worked example of deferral ```java interface PaymentGateway { Receipt charge(Money m); } class StripeGateway implements PaymentGateway { /* ... */ } class PaypalGateway implements PaymentGateway { /* ... */ } class Gateways { static PaymentGateway forRegion(Region r) { // factory method return switch (r) { case US, CA -> new StripeGateway(); case EU -> new PaypalGateway(); }; } } // caller: depends only on the PaymentGateway interface PaymentGateway g = Gateways.forRegion(region); Receipt rcpt = g.charge(amount); ``` The calling code never names `StripeGateway` or `PaypalGateway`. The *which-class* decision lives entirely inside `Gateways.forRegion`. Adding `AdyenGateway` for a new region is a change *only* inside the factory (or a registry); no caller changes. The instantiation was "deferred" to the factory and is now trivially evolvable. ## How this realizes Open/Closed The **Open/Closed Principle (OCP)** says software entities should be *open for extension but closed for modification* — you should be able to add new behaviour without editing existing, tested code. Factory-method-over-interface delivers OCP *at the creation site*: - **Open for extension:** add a new class implementing the interface and make it reachable (register it, or extend the factory's mapping). - **Closed for modification:** existing callers, which depend only on the interface, are untouched. In the strongest form (a registry/SPI), even the factory needn't be edited. ## The JDK's runtime-discovery version: ServiceLoader / SPI The JDK pushes deferral to its limit with **SPI (Service Provider Interface)** and `java.util.ServiceLoader`. A *service* is an interface; *providers* are implementing classes declared in module metadata or `META-INF/services`. `ServiceLoader.load(Service.class)` discovers and instantiates whatever providers are on the module path at runtime. Here the set of concrete classes isn't even known when the consuming code is compiled — it's a factory whose products are *plugins*. JDBC drivers, `NumberFormat`/`Calendar` locale providers, and `Charset` providers all work this way. This is the ultimate deferred instantiation: the concrete class is chosen at runtime from a dynamically discovered, externally supplied set. ## Trade-offs and pitfalls - **Indirection cost.** You can no longer see the concrete type at the call site, which can hinder reading and debugging; navigation goes through the factory. - **Over-abstraction.** Introducing an interface + factory for a class with a single implementation and no extension need is speculative complexity (YAGNI). Add the seam when variation is real or clearly imminent. - **Discoverability.** Constructors are obvious; factory methods must be found and named well. - **Leaky returns.** If callers downcast the interface back to a concrete type, the decoupling is lost and OCP benefits evaporate — code to the interface. ## Interview takeaway State the chain crisply: *interface = contract callers depend on; implementations = interchangeable concretes; factory returns the interface and owns the which-class choice (deferred instantiation); this yields OCP at the creation site; the JDK's `ServiceLoader`/SPI is the runtime-discovery generalization.* Then name the trade-off (indirection / don't abstract speculatively) to show judgment.