The Open Closed Principle states that in an OO
software architecture, classes
should be both closed in that they are complete
on their own, and open in that they are extendible by inheritance
Imagine you have a class X that performs a general task, and you wish to implement code that performs a more specialised task related to the task performed by X.
You can directly alter the code of X to deal with the special case. The problem inherent in this is that you would be forever altering the code of every class in your system to deal with every special case. The classes would not be closed, and you'd have a maintenance nightmare.
You could copy the code of class X, paste it and rename the copy X'. At first this seems like a good option - after all, you've managed to keep the original X closed and allowed for an extension. You're a software engineering genius.
Actually, you're not. If you duplicate the above behaviour ten times for various special cases, you end up with a lot of strangely named classes duplicating the same behaviour again and again.
The solution is inheritance. Inheritance is a language feature that lets a class take on the properties of another, and also allows it to redefine some of these properties and add new ones. The system remains relatively simple compared to the other solutions - if you change the properties of the base class (the one inherited from), then all derived classes will take on this new behaviour. This is similar in a way to the Single Choice Principle, which states that behaviour or data should be defined at most once in a system. This way, if a change is needed, it need only be changed in this one place.
So, the solution to our above problem? Easy. Define a new class Y that inherits from X. X is closed - no changes have been made to it, no new bugs introduced - but it is also open because we were able to extend it.