Constructors vs Factory Methods [closed]

by

Ask yourself what they are and why do we have them. They both are there to create instance of an object.

ElementarySchool school = new ElementarySchool();
ElementarySchool school = SchoolFactory.Construct(); // new ElementarySchool() inside

No difference so far. Now imagine that we have various school types and we want to switch from using ElementarySchool to HighSchool (which is derived from an ElementarySchool or implements the same interface ISchool as the ElementarySchool). The code change would be:

HighSchool school = new HighSchool();
HighSchool school = SchoolFactory.Construct(); // new HighSchool() inside

In case of an interface we would have:

ISchool school = new HighSchool();
ISchool school = SchoolFactory.Construct(); // new HighSchool() inside

Now if you have this code in multiple places you can see that using factory method might be pretty cheap because once you change the factory method you are done (if we use the second example with interfaces).

And this is the main difference and advantage. When you start dealing with a complex class hierarchies and you want to dynamically create an instance of a class from such a hierarchy you get the following code. Factory methods might then take a parameter that tells the method what concrete instance to instantiate. Let’s say you have a MyStudent class and you need to instantiate corresponding ISchool object so that your student is a member of that school. 

ISchool school = SchoolFactory.ConstructForStudent(myStudent);

Now you have one place in your app that contains business logic that determines what ISchool object to instantiate for different IStudent objects.

So – for simple classes (value objects, etc.) constructor is just fine (you don’t want to overengineer your application) but for complex class hierarchies factory method is a preferred way.

This way you follow the first design principle from the gang of four book “Program to an interface, not an implementation”.

More Related Contents:

  1. What does “program to interfaces, not implementations” mean?
  2. Why do we use Interface? Is it only for Standardization? [closed]
  3. Difference Between Cohesion and Coupling
  4. What does ‘low in coupling and high in cohesion’ mean
  5. What is an example of the Liskov Substitution Principle?
  6. Why doesn’t Rust support trait object upcasting?
  7. Inheritance vs. Aggregation [closed]
  8. What is the exact problem with multiple inheritance?
  9. Why can’t I seem to grasp interfaces?
  10. HAS-A, IS-A terminology in object oriented language
  11. Functional programming vs Object Oriented programming [closed]
  12. Explanation of the UML arrows
  13. What is the rationale behind having companion objects in Scala?
  14. Where do I use delegates? [closed]
  15. What is the dependency inversion principle and why is it important?
  16. Do write-only properties have practical applications?
  17. Polymorphism – Define In Just Two Sentences [closed]
  18. DDD – the rule that Entities can’t access Repositories directly
  19. Why “private” methods in the object oriented?
  20. What is the meaning and reasoning behind the Open/Closed Principle?
  21. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  22. If-less programming (basically without conditionals) [closed]
  23. Are there any rules for OOP?
  24. What is the real difference between “Bastard Injection” and “Poor Man’s Injection”
  25. When to implement an interface and when to extend a superclass?
  26. Differences between Proxy and Decorator Pattern
  27. Mixin vs inheritance
  28. Does the Single Responsibility Principle work in OOP?
  29. Learning/Implementing Design Patterns (For Newbies) [closed]
  30. Coupling, Cohesion and the Law of Demeter

Leave a Comment