Open/closed principle
| SOLID |
|---|
| Principles |
Clever application design and the code writing part should take care of the frequent changes that are done during the development and the maintaining phase of an application. Usually, many changes are involved when a new functionality is added to an application. Those changes in the existing code should be minimized, since it's assumed that the existing code is already unit tested and changes in already written code might affect the existing functionality in an unwanted manner.
The Open Close Principle states that the design and writing of the code should be done in a way that new functionality should be added with minimum changes in the existing code. The design should be done in a way to allow the adding of new functionality as new classes, keeping as much as possible existing code unchanged. The name Open/Closed Principle has been used in two ways. Both ways use inheritance to resolve the apparent dilemma, but the goals, techniques, and results are different.
Contents |
Meyer's Open/Closed Principle[edit]
Bertrand Meyer is generally credited as having originated the term Open/Closed Principle,[1] which appeared in his 1988 book Object Oriented Software Construction. The idea was that once completed, the implementation of a class could only be modified to correct errors; new or changed features would require that a different class be created. That class could reuse coding from the original class through inheritance. The derived subclass might or might not have the same interface as the original class.
Meyer's definition advocates implementation inheritance. Implementation can be reused through inheritance but interface specifications need not be. The existing implementation is closed to modifications, and new implementations need not implement the existing interface.
Polymorphic Open/Closed Principle[edit]
During the 1990s, the Open/Closed Principle became popularly redefined to refer to the use of abstracted interfaces, where the implementations can be changed and multiple implementations could be created and polymorphically substituted for each other.
In contrast to Meyer's usage, this definition advocates inheritance from abstract base classes. Interface specifications can be reused through inheritance but implementation need not be. The existing interface is closed to modifications and new implementations must, at a minimum, implement that interface.
Robert C. Martin's 1996 article "The Open-Closed Principle"[2] was one of the seminal writings to take this approach. In 2001 Craig Larman related the Open/Closed Principle to the pattern by Alistair Cockburn called Protected Variations, and to the David Parnas discussion of information hiding.[3]
See also[edit]
- SOLID – the "O" in "SOLID" stands for the open/closed principle
References[edit]
- ^ Robert C. Martin "The Open-Closed Principle", C++ Report, January 1996, pp. 1
- ^ Robert C. Martin "The Open-Closed Principle", C++ Report, January 1996
- ^ Craig Larman, "Protected Variation: The Importance of Being Closed", IEEE Software May/June 2001, pp. 89-91 [1]
