Re: Collection, enum or something else?

Mark,

Thanks for your very clear response. I agree that it I had
complicated
my example a bit. I have been trying to come up with ways to ask
questions here without exposing too much of what I am really working
on and not using names that invoke the ire of would be respondents (my
example started with Tree, but then I thought that Shrub would be less
prone to Java-naming collisions). That said, I have some follow-on
questions.

With your set-up, I then suppose that you would have some sort of
getters for the collections within ShrubsOfTheWorld and then
iterate on the returned collection as needed? The direct access
to Shrub methods is again lost without an intermediate object.

How would you handle a memory intensive application wherein an
intermediate object could be have a significant impact on memory?
I am coming back to wondering whether an interface provides the
proper mechanism for reducing unnecessary objects.

An example to (hopefully) provide clarity (assume an known finite
list of shrubs):

public interface Shrub
{
    Color getColor();
    double getHeight();
}

public class ShrubProperties implements Shrub
{
    public ShrubProperties( Color color, double height )
    {
        this.color = color;
        this.height = height;
    }

    public Color getColor()
    {
        return color;
    }

    public double getHeight()
    {
        return height;
    }

    private Color color = null;
    private double height = 0.d;
}

public enum NorthAmericanShrub implements Shrub
{
    // Assume that these are all the shrubs that I
    // will ever need - this is an example, not meant
    // to be true to life
    aShrub( new Shrub( Color.BLUE, 20.d ) ),
    bShrub( new Shrub( Color.GREEN, 1.d ) ),
    cShrub( new Shrub( Color.RED, 34.56d ) );

    public NorthAmericanShrub( Shrub shrub )
    {
        this.shrub = shrub;
    }

    public Color getColor()
    {
        return shrub.getColor();
    }

    public double getHeight()
    {
        return shrub.getHeight();
    }

    private Shrub shrub = null;
}

Elsewhere, it is possible to access the enumerated
Shrub directly due to the interface (which I guess
isn't _required_ it just enforces the contract), such
as:

public void someMethod()
{
    for( Shrub shrub : NorthAmericanShrubs.values() )
    {
        System.out.println( "Shrub color:" + shrub.getColor() );
        System.out.println( "Shrub height:" + shrub.getHeight() );
    }
}

This eliminates the need for the intermediate object
shown in the original post. This is likely still not
the most proper way to do this. I tend to see things
in a very complicated fashion (simplicity eludes me).

I am not intending to discount your response in anyway,
just trying to grasp good design and maybe learn more
about proper use of the interface class.

Thanks again,
Todd

BTW, none of the above code has been compiled let alone tested