Java polymorphism: finding the right design pattern

Question

Disclaimer: I know there are a lot of questions about polymorphism out there, but I couldn't find a suitable answer for my problem. If your Google-fu is better than mine, please forgive the dupe.

I have a model using inheritance, such as in the example below.

public abstract class Base {
// ...
}

public class ConcreteA extends Base {
    private String someString;
// ...
}

public class ConcreteB extends Base {
    private boolean someBool;
// ...
}

And I also have a List<Base>, which is composed of objects that are either ConcreteAs or ConcreteBs.

I need to generate a graphical view for each object in the list, but the resulting element is not the same for ConcreteAs and ConcreteBs. From the example above, the view for ConcreteA would be a text field, while the view for a ConcreteB would be a check box.

How can I achieve this using OO principles?

It's not quite clear what do you mean by "resulting element is not the same for ConcreteA and ConcreteB". But in general, OO principles state that Object should mostly be personally responsible for all actions with it, including rendering. So OO principles would dictate a renderTo(Media) method, but that is a WHOLE LOAD of cans of its own worms. So try to use something like a specialized renderer instances, each knowing how to render what. — M. Prokhorov
– M. Prokhorov, Commented Jul 5, 2017 at 15:30

René Link · Accepted Answer · 2017-07-06 09:02:18Z

2

The problem that you have is that you somewhere return a List<Base> when the caller must know the concrete type.

Usually this is caused because one tried to make a method more generic. E.g. if someone has this service methods

public List<ConcreteA> doSomethingA(){ ... }
public List<ConcreteB> doSomethingB(){ ... }

he might think it is a better idea to introduce a superclass, Base so that both methods can be substituted by

public List<Base> doSomething(){ ... }

This is a good idea if the caller is only interessted in a Base object. This means that ConcreateA and ConcreteB have some common behavior that the caller only depends on.

But in your case it seems that the caller needs the concrete type information that is not available anymore, because of the more generic method.

So you either must preserve or reconstruct the type information.

Preserve the type by using a custom return type instead of making the method generic

 public class Result {
     private List<ConcreteA> concreteA;
     private List<ConcreteB> concreteA;
 }

 public Result doSomething();

Recunstruct the type information using instanceof
Reconstruct the type information by introcucing a visitor pattern.

answered Jul 6, 2017 at 9:02

René Link

52k15 gold badges119 silver badges152 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Richard-Degenne Over a year ago

I like this answer. I was about to accept the one suggesting the Visitor pattern, because this is what I'm going to settle for, and the additional details you provide consolidate this choice. From a business point of view, it really is just a List<Base>, but each concrete class behaves differently, and I don't want to include everything in the business model. Thank you for taking the time to write this up. :)

OldCurmudgeon · Accepted Answer · 2017-07-05 15:32:36Z

2

Not a pattern - this is what abstraction is all about. Declare a method you want all subclasses of Base to implement and each must implement it in their own way.

Obviously you would pass parameters and/or get results of the methods.

public abstract class Base {
    abstract void graphicalView();
}

public class ConcreteA extends Base {
    @Override
    void graphicalView() {

    }
}

public class ConcreteB extends Base {
    @Override
    void graphicalView() {

    }
}

public void test() throws IOException {
    List<Base> bases = new ArrayList<>();
    for ( Base b : bases ) {
        b.graphicalView();
    }
}

answered Jul 5, 2017 at 15:32

OldCurmudgeon

66k18 gold badges126 silver badges220 bronze badges

2 Comments

Richard-Degenne Over a year ago

Is there some way to export this functionality out of the model classes while keeping this behavior? I feel like handling the graphical interface has nothing to do in the models.

OldCurmudgeon Over a year ago

@RichouHunter Then make the graphicalView return an object that can be rendered. Maybe make it return some XML you can then run through an XSLT transform into HTML. Or maybe return a State which can then be rendered externally.

Mickael · Accepted Answer · 2017-07-05 15:32:55Z

2

I think you're looking for Visitor Design Pattern.

From Wikipedia :

In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to extant object structures without modifying the structures. It is one way to follow the open/closed principle.

In essence, the visitor allows adding new virtual functions to a family of classes, without modifying the classes. Instead, a visitor class is created that implements all of the appropriate specializations of the virtual function. The visitor takes the instance reference as input, and implements the goal through double dispatch.

answered Jul 5, 2017 at 15:32

Mickael

4,5882 gold badges30 silver badges40 bronze badges

3 Comments

OldCurmudgeon Over a year ago

Not certain this is Visitor - feels more like Bridge to me.

Mickael Over a year ago

I see your point. But in this case, I think it would be better if you could separate the structure and the model (List<Base> of ConcreteA and ConcreteB) from the behavior (Drawing). Which is not the case with Bridge design pattern.

Richard-Degenne Over a year ago

I wish I could accept two answers. The Visitor pattern looks like the way to go (thanks for suggesting it), but René's answer provides very useful information.

urag · Accepted Answer · 2017-07-05 15:46:17Z

-1

In such cases, I usually use generics something like this

public abstract  class Base <T extends  Shape>{
public abstract T drawShape();

}

public class ConcreatA extends Base<Circle> {
@Override
public Circle drawShape() {
    return null;
}

}

public class ConcreatB extends Base<Square> {
@Override
public Square drawShape() {
    return null;
}

}

So now you can use list of Shapes

edited Jul 5, 2017 at 15:46

answered Jul 5, 2017 at 15:31

urag

1,2589 silver badges32 bronze badges

Collectives™ on Stack Overflow

Java polymorphism: finding the right design pattern

4 Answers 4

1 Comment

2 Comments

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

2 Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related