How would I nest a shape within a shape in Java?

Question

I am trying to do an assignment involving bouncing shapes within a JPanel. Whenever shapes hit a side, they will bounce off in the other direction. I have already got the bouncing part working for normal shapes, but now I need to make a NestingShape.

The NestingShape is a rectangle that contains zero or more Shapes that bounce around inside it, while the NestingShape bounces around the in the JPanel. The children of a NestingShape instance can be either simple Shapes, like RectangleShape and OvalShape objects, or other NestingShape instances.

The specification for the NestingShape is below:

public class NestingShape extends Shape {   
    /**
     * Creates a NestingShape object with default values for state.
     */
    public NestingShape() {
        super();
    }

    /**
     * Creates a NestingShape object with specified location values, default values for other
     * state items.
     */
    public NestingShape(int x, int y) {
        super(x,y);
    }

    /**
     * Creates a NestingShape with specified values for location, velocity and direction.
     * Non-specified state items take on default values.
     */
    public NestingShape(int x, int y, int deltaX, int deltaY) {
        super(x,y,deltaX,deltaY);
    }

    /**
     * Creates a NestingShape with specified values for location, velocity, direction, width, and
     * height.
     */
    public NestingShape(int x, int y, int deltaX, int deltaY, int width, int height) {
        super(x,y,deltaX,deltaY,width,height);
    }

    /**
     * Moves a NestingShape object (including its children) with the bounds specified by arguments
     * width and height.
     */
    public void move(int width, int height) {
        //Not yet implemented
    }

    /**
     * Paints a NestingShape object by drawing a rectangle around the edge of its bounding box.
     * The NestingShape object's children are then painted.
     */
    public void paint(Painter painter) {
        painter.drawRect(fX,fY,fWidth,fHeight);
        painter.translate(fX,fY);
        // Paint children here. Not implemented yet
        painter.translate(0,0);
}

    /**
     * Attempts to add a Shape to a NestingShape object. If successful, a two-way link is
     * established between the NestingShape and the newly added Shape. Note that this method
     * has package visibility - for reasons that will become apparent in Bounce III.
     * @param shape the shape to be added.
     * @throws IllegalArgumentException if an attempt is made to add a Shape to a NestingShape
     * instance where the Shape argument is already a child within a NestingShape instance. An
     * IllegalArgumentException is also thrown when an attempt is made to add a Shape that will
     * not fit within the bounds of the proposed NestingShape object.
     */
    void add(Shape shape) throws IllegalArgumentException {
        // Not implemented yet  
    }

    /**
     * Removes a particular Shape from a NestingShape instance. Once removed, the two-way link
     * between the NestingShape and its former child is destroyed. This method has no effect if
     * the Shape specified to remove is not a child of the NestingShape. Note that this method
     * has package visibility - for reasons that will become apparent in Bounce III.
     * @param shape the shape to be removed.
     */
    void remove(Shape shape) {
        // Not implemented yet
    }

    /**
     * Returns the Shape at a specified position within a NestingShape. If the position specified
     * is less than zero or greater than the number of children stored in the NestingShape less
     * one this method throws an IndexOutOfBoundsException.
     * @param index the specified index position.
     */
    public Shape shapeAt(int index) throws IndexOutOfBoundsException {
        // Not implemented yet
    }

    /**
     * Returns the number of children contained within a NestingShape object. Note this method is
     * not recursive - it simply returns the number of children at the top level within the callee
     * NestingShape object.
     */
    public int shapeCount() {
        // Not implemented yet
    }

    /**
     * Returns the index of a specified child within a NestingShape object. If the Shape specified
     * is not actually a child of the NestingShape this method returns -1; otherwise the value
     * returned is in the range 0 .. shapeCount() - 1.
     * @param the shape whose index position within the NestingShape is requested.
     */
    public int indexOf(Shape shape) {
        // Not implemented yet
    }

    /**
     * Returns true if the shape argument is a child of the NestingShape object on which this method
     * is called, false otherwise.
     */
    public boolean contains(Shape shape) {
        // Not implemented yet
    }
}

I'm not sure if that provides enough context, but the part I am having trouble with is implementing the add and remove methods. When it says "a two-way link is established between the NestingShape and the newly added Shape", I don't know how I'd go about doing that. Would I use an ArrayList or List of Shapes or something else? Are there any clues on how I'd go about implementing the add method and where the method would be called from within this code?

Thanks.

Answer 1

If I get this right, you do in fact need to have some sort of list (ArrayList for example) or ordered-set of children inside this nesting shape, so that the nesting shape could have more children. You can then use the list's method to check when adding a shape if it's already contained, and remove and insert shapes.

When they say you establish a two way connection they mean that you should some how tell the inserted shape that now it's new parent is the given nested shape. You have not given us the interface of the shape class (and it does not look like the standard java.awt.Shape since that is an interface). Your shape class does reference somehow a parent rectangle to know what are the boundries in which it should move, so you should set that parent to be the nesting-shape upon inserting the child shape into the nesting-shape. You should also remove that parent-child relation upon removing the shape from the nesting shape.

I'll need more info on the shape class to provide a more detailed answer, but I believe this is what you were looking for ;)