04bf566dc1
* Grammatical fixes to command pattern * Update bridge pattern readme * Fixes to builder pattern grammar * Update chain of responsibility * Improvements to the composite example * Fixes to headings * Minor updates to decorator pattern * Update facade * Update factory example * Update factory method * Update flyweight * Interpreter explanation * Update iterator readme * Add explanation for mediator pattern * Grammatical fixes to memento * Grammar fixes for observer * Update explanation for the prototype pattern * Proxy pattern grammar fixes * Update singleton * Grammar fixes to state pattern * Grammar fixes for strategy * Grammar fixes, template method * Grammar fixes for visitor * Fix typo
117 lines
4.5 KiB
Markdown
117 lines
4.5 KiB
Markdown
---
|
|
layout: pattern
|
|
title: Factory Method
|
|
folder: factory-method
|
|
permalink: /patterns/factory-method/
|
|
categories: Creational
|
|
language: en
|
|
tags:
|
|
- Extensibility
|
|
- Gang of Four
|
|
---
|
|
|
|
## Also known as
|
|
|
|
Virtual Constructor
|
|
|
|
## Intent
|
|
|
|
Define an interface for creating an object, but let subclasses decide which class to instantiate.
|
|
Factory Method lets a class defer instantiation to subclasses.
|
|
|
|
## Explanation
|
|
|
|
Real-world example
|
|
|
|
> Blacksmith manufactures weapons. Elves require Elvish weapons and orcs require Orcish weapons.
|
|
> Depending on the customer at hand the right type of blacksmith is summoned.
|
|
|
|
In plain words
|
|
|
|
> It provides a way to delegate the instantiation logic to child classes.
|
|
|
|
Wikipedia says
|
|
|
|
> In class-based programming, the factory method pattern is a creational pattern that uses factory
|
|
> methods to deal with the problem of creating objects without having to specify the exact class of
|
|
> the object that will be created. This is done by creating objects by calling a factory method
|
|
> — either specified in an interface and implemented by child classes, or implemented in a base
|
|
> class and optionally overridden by derived classes—rather than by calling a constructor.
|
|
|
|
**Programmatic Example**
|
|
|
|
Taking our blacksmith example above. First of all, we have a `Blacksmith` interface and some
|
|
implementations for it:
|
|
|
|
```java
|
|
public interface Blacksmith {
|
|
Weapon manufactureWeapon(WeaponType weaponType);
|
|
}
|
|
|
|
public class ElfBlacksmith implements Blacksmith {
|
|
public Weapon manufactureWeapon(WeaponType weaponType) {
|
|
return ELFARSENAL.get(weaponType);
|
|
}
|
|
}
|
|
|
|
public class OrcBlacksmith implements Blacksmith {
|
|
public Weapon manufactureWeapon(WeaponType weaponType) {
|
|
return ORCARSENAL.get(weaponType);
|
|
}
|
|
}
|
|
```
|
|
|
|
When the customers come, the correct type of blacksmith is summoned and requested weapons are
|
|
manufactured:
|
|
|
|
```java
|
|
Blacksmith blacksmith = new OrcBlacksmith();
|
|
Weapon weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
|
|
LOGGER.info("{} manufactured {}", blacksmith, weapon);
|
|
weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
|
|
LOGGER.info("{} manufactured {}", blacksmith, weapon);
|
|
|
|
blacksmith = new ElfBlacksmith();
|
|
weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
|
|
LOGGER.info("{} manufactured {}", blacksmith, weapon);
|
|
weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
|
|
LOGGER.info("{} manufactured {}", blacksmith, weapon);
|
|
```
|
|
|
|
Program output:
|
|
```
|
|
The orc blacksmith manufactured an orcish spear
|
|
The orc blacksmith manufactured an orcish axe
|
|
The elf blacksmith manufactured an elven spear
|
|
The elf blacksmith manufactured an elven axe
|
|
```
|
|
|
|
## Class diagram
|
|
|
|
|
|
|
|
## Applicability
|
|
|
|
Use the Factory Method pattern when:
|
|
|
|
* Class cannot anticipate the class of objects it must create.
|
|
* Class wants its subclasses to specify the objects it creates.
|
|
* Classes delegate responsibility to one of several helper subclasses, and you want to localize the
|
|
knowledge of which helper subclass is the delegate.
|
|
|
|
## Known uses
|
|
|
|
* [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--)
|
|
* [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-)
|
|
* [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--)
|
|
* [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-)
|
|
* [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-)
|
|
* [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-)
|
|
* [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--)
|
|
|
|
## Credits
|
|
|
|
* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
|
|
* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
|
|
* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
|