Design/code reusage problem

[turanan]

Here is my issue.

I have a class. Lets call it GeneralClass. This class has a method, lets call it methodInQuestion(), which I need to change. Here's an example of how the code behaves now:

public void GeneralClass() {
    methodInQuestion(ParentParameterType a) {
        doGeneralThing();
}

I need to change it to something like this:

public void GeneralClass() {
    methodInQuestion(ParentParameterType a) {
            if(a instanceof ChildParameterType) {
                doSpecificThing();
            }
            doGeneralThing();
}

The problem is however, that this is a poor design solution, since this specific behavior occurs very seldom, but my check would occur each time when this method is used. Instead of changing my general class, I created a new ChildParemeterType class and have overridden the method. That is a much better design solution, however, given that I have to copy-paste quite a large method for just one line of code, this solves my design problem only to create a reusage problem.

So my question is: how can I solve this problem in a way that I don't have to copy-paste and can reuse the code from my methodInQuestion() method.

Any advice or comments are appreciated.
Andrew

[masijade]

What is "GeneralType", what is "MoreSpecificSubClassType", what is "a", and how do all of these relate to "GeneralClass".

See, it might help to see the real code. At least the real declaration and definition of the real a, and the real class declarations of the real GeneralClass, GeneralType, MoreSpecificSubClassType, and the real declarations of doGeneralThing, doSpecificThing, and the real declaration of methodInQuestion and the real code of the "instanceof" involved.

[Cbani]

not very sure. but probably we could make use of strategy design pattern.

[JosAH]

not very sure. but probably we could make use of strategy design pattern.

There are several options: if a has one of a fixed set of types (classes) a double dispatch (i.e. a visitor) can do the job; otherwise make an interface with a single method and have all types of a implement that interface; that way your GeneralClass never has to change.

kind regards,

Jos

[turanan]

What is "GeneralType", what is "MoreSpecificSubClassType", what is "a", and how do all of these relate to "GeneralClass".

See, it might help to see the real code. At least the real declaration and definition of the real a, and the real class declarations of the real GeneralClass, GeneralType, MoreSpecificSubClassType, and the real declarations of doGeneralThing, doSpecificThing, and the real declaration of methodInQuestion and the real code of the "instanceof" involved.

Thank you for you reply!

This may help to understand the code:

I'll rename some of the classes and variables to make the code clearer:

public void GeneralClass() {
    methodInQuestion(ParentParameterType a) {
        doGeneralThing();
}

I need to change it to something like this:

public void GeneralClass() {
    methodInQuestion(ParentParameterType a) {
            if(a instanceof ChildParameterType) {
                doSpecificThing();
            }
            doGeneralThing();
}

ChildParameterType extends ParentParameterType
a is basically a parameter of methodInQuestion().The reference to this object is of type ParentParameterType, but the object itself is of the type, that is a subclass of ParentParameterType. The behavior used to be the same for all children of ParentParameterType, but now, specifically if a is of that one specific ChildParameterType subtype, we must make some specific actions.

Here is how a could be declared and initialized:

ParentParameterType a = new ChildParameterType();
now this ChildParameterType is that specific subclass of ParentParameterType, for which I want the specific behaviour

I'm sorry that I can't post the real code, since it is too sensitive, and I really doubt that it would be clearer than the example.

[masijade]

Can't "MoreSpecificSubClassType" simply override the "doGeneralThing" method definition? Or how do those methods come into it? Also, is "GeneralClass" abstract? Whether it is or not, you could also simply extend it for the instances where "MoreSpecificSubClassType" would be expected, etc, etc.

[turanan]

There are several options: if a has one of a fixed set of types (classes) a double dispatch (i.e. a visitor) can do the job; otherwise make an interface with a single method and have all types of a implement that interface; that way your GeneralClass never has to change.

kind regards,

Jos

Thanks for the reply!

Interface will basically do the same thing as I have done with creating the subclass of GeneralType and overriding this one method. Interface would be better, if this specific behavior had to be used by several classes, but this is not the case.

I am not familiar with the double dispatch approach, so maybe this could help.

Andrew

[JosAH]

I am not familiar with the double dispatch approach, so maybe this could help.

Double dispatch is also known under the name 'visitor pattern' (as I wrote) and is one of the patterns mentioned in the GoF book.

kind regards,

Jos

[turanan]

Double dispatch is also known under the name 'visitor pattern' (as I wrote) and is one of the patterns mentioned in the GoF book.

kind regards,

Jos

Thank you, I will read it up.

[senorbum]

Why are you concerned about making an if check? Unless you are very, very concerned about performance this seems like something that just wouldn't make a large impact on things.

[Tolls]

The only concern I would have for an if check like that is that it tends to be a sign you've got your model wrong.

[JosAH]

The only concern I would have for an if check like that is that it tends to be a sign you've got your model wrong.

It is; a visitor pattern hides that 'if' but you need a fixed set of classes for that otherwise you have to change the visitor (and its implementation) all the time. IMHO a simple interface for those 'a' classes could do the job; i.e. every class is free to implement whatever it wants. The other side of the medal is that those classes are implementing the functionality instead of that 'GeneralClass'; I don't consider that a disadvantage.

kind regards,

Jos

[Tolls]

Yes.
To me it implies that the wrong class is doing the work, and it probably ought to be done by the class/object you're calling instanceof on. Hence your interface suggestion.