Implementing Factory Method in Java

Factory Method is implemented with inheritance. You start with an abstract creator class that has an abstract factory method returning an interface type. Then you write a template method in the parent that calls the factory method to get an object and does the shared work with it — and crucially, the parent depends only on the interface, not any concrete class. Finally, you write subclasses that override the factory method to return specific implementations. The structure means the parent owns the workflow without knowing the exact types, and subclasses supply the types. Let me make it concrete with a report service. You define an abstract ReportService with an abstract method createGenerator that returns a ReportGenerator interface. Then you write an export method in the parent that calls createGenerator, then calls generate on whatever it gets back. The parent doesn't know if it's a PDF or Excel generator. Now you create subclasses, PdfReportService and ExcelReportService, and each overrides createGenerator to return its specific generator. The export method is identical for both, but it produces different reports because the factory method is overridden. The mistake freshers make is confusing this with Simple Factory. Factory Method needs inheritance and an overridden method — a static helper is Simple Factory. The other mistake is having no template method; if you override the creation method but nothing in the parent actually calls it, you've lost the whole benefit. The key difference to call out is this: with Simple Factory you edit an existing switch to add a type, but with Factory Method you add a new subclass and never touch existing code. That's why Factory Method is the Gang of Four pattern — it follows Open Closed and inverts control.