The Open-Closed principle states that the design of a software system should be open for extension, but individual classes should be closed for modification. This means that a software should be designed such that new functionality can be added by adding new classes, and by subclassing abstract classes that have already been defined. However once a class is implemented it should be closed for modifications.
Such a design can be achieved by using the "Program To An Interface" concept. This concept states that the client class must reference abstract classes instead of concrete classes. This way subclasses can be added to the system as new functionality is added, without breaking client code. Care must be taken so as not to instantiate concrete classes in the client code. The creation of concrete subclasses must be handled by object factories. The dependency inversion principle ensures proper implementation of the open-close principle.
To summarize: we must achieve extensibility in a software system by adding new classes (subclasses) and not by modifying existing classes.
Here is an example to better understand this principle.
Spec: We want to design a software which will play a selected tune on a selected musical instrument.
The system will have the following classes:
public class Tune {
}
public class Instrument {
public abstract void play(Tune tune);
}
public class Guitar extends Instrument {
public void play(Tune tune) {
//play the tune using a Guitar
}
}
public class Harmonium extends Instrument {
public void play(Tune tune) {
//play the tune using a Harmonium
}
}
The client code is the code which uses these objects and invokes the play method.
public class Jukebox {
public void playMusic() {
Tune tune = getUserSelectedTune();
Instrument instr = getUserSelectedInstrument();
instr.play(tune);
}
}
Notice that the client code (Jukebox) does not instantiate a particular instrument subclass. It simply gets the instrument (superclass) reference from a method that is responsible for creating a concrete instrument . If the specification changes and we wish to add more instruments in our system, all we have to do is create subclasses of Instrument, override the play method, and modify the method getUserSelectedInstrument(). The client code in Jukebox does not need to be changed. Incorporating the change in specification was easy and minimal code had to be touched because we used the open-closed principle.
Comments