Instantiating an enum

[Varnam Aayiram]

Hi Folks,

Is it possible to instantiate an enum? I have the following enum in a stand alone file, as in it's not part of of another class:

FileName: CustomerType.java

public enum CustomerType {

    RETAIL,
    TRADE,
    COLLEGE;

     public String toString(String cType) {

        String s = cType;

         if (s.equalsIgnoreCase("RETAIL") ){
            s = "Retail Customer";
        } else if (s.equalsIgnoreCase ("TRADE")) {
            s = "Trade Customer";
        } else if (s.equalsIgnoreCase ("COLLEGE")) {
            s = "College Customer";
        }

        return s;

    }
}

In another class I have the following code to instantiate the enum so that I can invoke it's toString method with arguments. Following is my code extract to do that:

String customerType = "college";
 CustomerType ctp = new CustomerType();
 ctp.toString(customerType);

an error says enum types cannot be instantiated. Is there any other wat to invoke the toString method with arguments? Hope someone can advise. Thanks.

[N Sahni]

Hi,

Enums doesnot support public constructors and hence, cannot be instantiated.
In fact, each element in Enum like CustomerType.RETAIL are actually static instances of Enum.

You need to access toString() using any of these static instances or make the toString method static to have it accessible through CustomerType class.

[Jesper de Jong]

No, you cannot instantiate enums, and there's a good reason for that.

Enums are for when you have a fixed set of related constants. You don't want to instantiate one, because then the set would not be fixed. If you really want to write your enum like the way you did, then you can make the toString method static, so that you don't need an instance to call it on. You could then call it like this:

String customerType = "college";
CustomerType.toString(customerType);

But really, the code looks a little bit weird. Why does the toString method take a String as an argument? I would write the enum like this:

public enum CustomerType {
    RETAIL("Retail Customer"),
    TRADE("Trade Customer"),
    COLLEGE("College Customer");

    private final String description;

    private CustomerType(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return description;
    }
}

You then use it like this:

CustomerType customerType = CustomerType.RETAIL;
System.out.println(customerType.toString());

[Campbell Ritchie]

As Jesper has told you, you cannot instantiate enum members because they are already instantiated, so it is unnecessary.
There are ways you can improve your block of if-elses.

@Override public String toString()
{
   String description;
   switch (this)
   {
       case RETAIL:
          description = "Retail Customer";
          break;  
       case TRADE:
          description = "Trade Customer";
          break;
       case COLLEGE:
          description = "College Customer";
          break;
       default:
          throw new IllegalArgumentException();
   }
   return description;
}

But Jesper has already shown the you proper object-oriented way to do it. Far better than what I showed. Passing the argument to the constructor is correct. It also means you are overriding the toString() method rather than overloading it. Also when you have to change it, you simply add

        HOSPITAL ("Hospital customer"),

in the appropriate place, and everything will still work nicely.
And look at this:

System.out.println(CustomerType.RETAIL.toString("retail"));
System.out.println(CustomerType.COLLEGE.toString("retail"));
System.out.println(CustomerType.TRADE.toString("retail"));

[Rob Spoor]

The advantage of Jesper's approach is that you can never forget to add a name if you add an enum constant. With if-else statements and even switch statements it's much easier to forget, especially if you use multiple if-else or switch statements.

[Campbell Ritchie]

Yes, I did say what Jesper showed was far better than my switch.