Question

I have some doubts about a constructor.

There is a class “Foo” that can be created in three different “status” we could call them “YOUNG”, “ADULT” and “OLD”.

I want to underline that they cannot be seen as different classes because the object will evolve and if it has been created as “YOUNG” it will become “ADULT” and then “OLD” and so on..

My question is: how can I define one or more constructors to diversify these three typologies??

I see some possibilities, but no one is an “elegant” solution..

1) Create a constructor with an int as input

public Foo(int i)
{
    switch (i)
    {
         case 0:
         .
         .
         .
         case 1:
         .
         .
         .
         case 2:
         .
         .
         .
    }
}

but i do not like it because it is not so clear to understand if another person see this code.

2) Create a blank constructor and then create three different methods like

public Foo()
{

}

public void setYoungFoo()
{
    .
    .
    .
}

public void setAdultFoo()
{
    .
    .
    .
}

public void setOldFoo()
{
    .
    .
    .
}

This could be a clear way to resolve the problem, but i would resolve this problem in the constructor..

3) Could static variables usefull in this context?

public static final String "YOUNG";
public static final String "ADULT";
public static final String "OLD";


public Foo(String field)
{

}

I do not know how fill this constructor because I have never used static final variables (I have seen them used in some Java classes like Calendar even if not used in the contructor).

Could you please comment these three option to underline what are their disadvantages because I am quite sure that they can not be a good solution..

Answer 1

Use method 1, but with an enum instead of an int. You can even inline the enum in the class, just make it public static.

class Foo {
    public static enum fooState {
       young, adult, old;
    }

    public Foo(fooState i) {
        switch(i) {
        case young: ... break;
        case adult: ... break;
        case old: ... break;
        default: throw new InvalidStateException();
    }
    ...
}

Edit: You asked for opinions on your 3 options, here are mine:

1. Option 1 technically does the same as my version, but uses magic numbers (i.e. numbers without assigned name), which makes it harder to understand (both for other people and for your future self)
2. Option 2 leaves the class in an undefined or even invalid state between the Object creation and the call to set*Foo(). If you can make the transition to Young/Adult/Old at any time, it would be an option to set the Object to e.g. Young state in the constructor and let the user use the already necessary functions to switch to another state. Depends on the situation if this is a good option, but it is a valid one.
3. Option 3 is basically the same as Option 1, just slower because it involves string comparison. The code is easier to read if you call “new Foo(Foo.YOUNG)”, but it is not intuitive that you have to write it that way. Also, it would be possible to write “new Foo(“Alligator”)”, which would in the best case create a runtime error.