OO Design Principle - Open Closed Principle

Question

I have a Layout Manager Class and this class designed for setting datagrid layout. Code:

class LayoutManager
{
    private object _target;

    public LayoutManager(object aDataGrid)
    {
        _target = aDataGrid;
    }

    public void SaveLayout(string strProfileID)
    {
    }

    public void LoadLayout(string strProfileID)
    {
    }

    //in future I might add below function
    public void ResetLayout()//OtherFunction0
    {
    }

    public void OtherFunction1()
    {
    }

    public void OtherFunction2()
    {
    }


}

According to OCP "a Class should be open for extension, but closed for modification". If I add the new function in LayoutManager Class, is this action violate the OCP? If yes, what is the proper way to design the class?

If you haven't seen it already, take a look at this related question for background http://stackoverflow.com/q/59016/2065121 — Roger Rowland, Apr 10 '13 at 05:03

score 3 · Answer 1 · answered Apr 10 '13 at 04:56

I don't think that adding methods to a class in general violates the OCP prinicple, as this in fact extends the class's behviour. The problem is if you change existing behaviours. So that if the code on your added methods might change the behaviour of the existing methods (because it changes the object's state) that would be a violation.

The correct way to follow the SOLID principals, is to make an interface: ILayoutManager with the interfaces you want , with documented behaviours.

The class LayoutManager would implement this interface. Other new methods might be added in a new interface, say ILayoutFoo or added to the existing interface, as long as they won't break the contract of the documented behaviour in the existing methods.

score 1 · Answer 2 · answered May 01 '15 at 07:03

It's not possible to directly answer this without some concrete code.

Generally speaking though, the upshot of the OCP is that when classes derive from your base class and then override methods, the internal invariants shouldn't break because that's modification. There shouldn't be any way for the derived class to change those parts of the class' behaviour. The derived classes can change behaviour or add new functionality by using the parts exposed by the base class.

score 0 · Answer 3 · answered Sep 02 '17 at 05:04

Whenever we speak about Open-Closed Principle, one important issue comes into play, which is called Strategic Closure.

It should be clear that no significant program can be 100% closed. In general, no matter how “closed” a module is, there will always be some kind of change against which it is not closed. Since closure cannot be complete, it must be strategic. That is, the designer must choose the kinds of changes against which to close his design. This takes a certain amount of prescience derived from experience. The experienced designer knows the users and the industry well enough to judge the probability of different kinds of changes. He then makes sure that the open-closed principle is invoked for the most probable changes.

For example in famous sample of Shape class you just grantee that your program (in side of Client and Shape)just is closed for modification about adding new shape.

public class Shape {

    public draw() {
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        // implementation special to Circle
    }
}

public class Client {
...
    public drawMyShape(Shape shape) {
        shape.draw();
    }
...
}

According to this Strategy, when you are designing your program, you should make a decision about the sections that you want to be closed to changes. Therefore, in your example, when you were designing your program, if you decided that your entity (in this case it is GraphCalculator class) should be closed for modification and open to extension regarding to adding new functionality, adding new function in this example violates Open-Closed Principle, due to the fact that it changes implementation in side of client and GraphCalculator class. And solution can be using abstraction, which is mentioned in previous answers.

OO Design Principle - Open Closed Principle

3 Answers3