Sharing a list of base type with children

Question

I have a base class ShapeManager with a list of shapes which I want to enumerate(). Then there is a specialization ColoredShapeManager which wants to process specialized ColoredShapes instead of Shapes:

+----------------+      +-------------------------------------+
| Shape          |      | ShapeManager                        |
|----------------|      |-------------------------------------|
| + id: int      |      | # shapes: List<Shape>               |
|                |      |                                     |
|                |      | + ShapeManager() {                  |
|                |      |     shapes.add(new Shape());        |
|                |      |   }                                 |
|                |      |                                     |
|                |      | + abstract void enumerate() {       |
|                |      |     for (Shape s: shapes) {         |
|                |      |        // use s                     |
|                |      |     }                               |
|                |      |   }                                 |
+----------------+      +-------------------------------------+
         ^                              ^
         |                              |
         +                              +
+----------------+      +-------------------------------------+
| ColoredShape   |      | ColoredShapeManager                 |
|----------------|      |-------------------------------------|
| + color: int   |      | + ColoredShapeManager() {           |
|                |      |     shapes.add(new ColoredShape()); |
|                |      |   }                                 |
|                |      |                                     |
|                |      | + abstract void enumerate() {       |
|                |      |     for (Shape s: shapes) {         |
|                |      |       // use (ColoredShaped) s      |
|                |      |       // will fail for Shapes       |
|                |      |     }                               |
|                |      |   }                                 |
+----------------+      +-------------------------------------+

I am unsure whether ShapeManager should share shapes: List<Shape> with its children This seems flawed since ColoredShapeManager.enumerate() wants to process ColoredShapes. Hence it would cast the elements, yet some elements (those added by the base class) are of type Shape and the cast would fail.

That is:

• Both types of shape end up in the list shapes.
• enumerate() in the child manager should have access to ColoredShape.

Should I rather split the list and create private lists in each of the two managers? Then enumerate in the child would only iterate over "its" type of shapes and call the parent's enumerate() at the start/end.

Answer 1

You can add the shape type as the "type parameter" for your manager classes. So basically, ColoredShapeManager can extend ShapeManager<ColoredShape> and this T will be the type of your internal List data structure. Also, if your ColoredShapeManager doesn't do anything specific with the ColoredShapes, I would argue that it doesn't even need a new class. But then again it depends on the way you are structuring your app/design.

Answer 2

Would the visitor pattern suit you here?

Shape

public void doSomething(ShapeManager) {
    ...
}

ShapeManager

abstract void enumerate() {
   for (Shape shape: shapes) {
       shape.doSomething(this);
   }
}

Then you wouldnt need to know the type and each shape derivative could have its own implementation.