ruthmoogChapter 8: Makin' Objects
This chapter is prep for removing the duplication of the times methods which multiply either Francs or Dollars.
The next step forward is not obvious
No, it is not. What we achieve though, involves having the two methods return the same type (Money as opposed to either Dollar or Franc): Makes sense!
We also use a factory in Money and that means we don't have to new up Dollar or Franc objects in the tests, but the book doesn't talk much about factories here, and since this terminology is used in a much simpler way here than I'm familiar with, I wanted to explore Java factories a little bit.
Factory Pattern
A Factory is an object which controls the creation and/or access to other objects - like the teller in a bank or a librarian in a library.
This means that a factory (or factory method) can simply be a method which creates a new object.
class Library {
/**
* The librarian is a factory method, controlling
* the creation of book loans.
*/
BookLoan Librarian(Book request) {
return new BookLoan(request);
}
}
But, instead of a librarian, we can have a dedicated factory method for the creation of the object, which makes the factory easier to maintain by encapsulating the creation behaviour, and it also allows us defer object instantiation to a sub-class.
Abstract factory methods need the subclasses to define an implementation.
Concrete factory methods are an interface and also define the implementation, and subclasses can override the implementation.
Static factory methods are efficient but don't allow subclasses to override the implementation. When invoked it's not needed to new up an instance like when using a constructor, and the instances can be controlled to avoid duplication and unnecessary object creation.
📚 Resources
🔎 View my code-along repo at https://github.com/ruthmoog/test-driven-development-by-example
