In this post I will speak about the second principle of Object Oriented Design (OOD), i.e. the Open-Closed Principle (OCP). in addition to the first one (SRP) which I have already spoken in my previous post.
This principle was coined by Bertrand Meyer, the same person who coined the term “design by contract”, to which I devoted an article that you can view on the UgiDotNet site.
This principle simply states that software entities, i.e. class, “should be opened for extensions but closed for modifications“.
Now, what does it really means ?
We all know that code changes according to changing requirements. When we design a module software, we design it according to certain requirements valid at the time. When requirements change we should be able to extend that software module, i.e. add new features in addition to existing ones, and the latter should not be changed for any reason.
In other words, when we create a module with certain features, that module must be immutable, and immutable means stable.
This principle apparently shows a contradiction: how can something that is immutable be subject to extensions, and then ultimately to change?
The answer lies in the use of abstract classes or interfaces. In fact, you can see it from this point of view: an interface or an abstract class, once created and established the methods and properties with their signatures, must be unalterable, but you can create different concrete classes which implement that interfaces and abstract classes, and then different implementations, and then modify or extend their behavior leaving the contract intact.
In this way, the software module is closed for modifications (the interface doesn’t never change), but is also open for extensions as you can create different implementations.
This principle would imply another principle: it’s necessary to design on interface and not on concrete implementations, otherwise the OCP would inexorably violated.