Java.lang.Enum Class in Java (original) (raw)

Last Updated : 24 Nov, 2021

Enum class is present in java.lang package. It is the common base class of all Java language enumeration types. For information about enums, refer enum in java

Class Declaration

public abstract class Enum extends Object implements Comparable, Serializable

As we can see, that Enum is an abstract class, so we can not create object of class Enum.

Methods in Enum Class

Enum class provides 10 useful methods. Most of them are overridden from Object class. These methods are declared as final in Enum class so the programmer cannot modify any of the enum constants.

1. final String name() : This method returns the name of this enum constant, which is exactly as declared in its enum declaration.
   Syntax :
   public final String name()
   Parameters :
   NA
   Returns :
   the name of this enum constant
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.RED;
`System.out.print(` `"Name of enum constant: "` `); ` System.out.println(c1.name());
   `` }
}
   Output:
   Name of enum constant: RED
2. final int ordinal() : This method returns index of this enumeration constant.
   Syntax :
   public final int ordinal()
   Parameters :
   NA
   Returns :
   the ordinal of this enumeration constant
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.GREEN;
`System.out.print(` `"ordinal of enum constant "` `+c1.name()+` `" : "` `); ` System.out.println(c1.ordinal());
   `` }
}
   Output:
   ordinal of enum constant GREEN : 1
3. String toString() : This method returns a String object representing this enumeration constant. This method is same as name() method.
   Syntax :
   public String toString()
   Parameters :
   NA
   Returns :
   a string representation of this enumeration constant
   Overrides :
   toString in class Object
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.GREEN;
`String str = c1.toString(); ` System.out.println(str);
   `` }
}
   Output:
   GREEN
4. final boolean equals(Object obj) : This method returns true if the specified object is equal to this enum constant , otherwise return false.
   Syntax :
   public final boolean equals(Object obj)
   Parameters :
   obj - the object too be compared for equality with this enum.
   Returns :
   true if the specified object is equal to this enum constant.
   false otherwise
   Overrides :
   equals in class Object
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.RED;
`Color c2 = Color.GREEN; ` Color c3 = Color.RED;
`boolean` `b1 = c1.equals(c2); ` boolean b2 = c1.equals(c3);
`boolean` `b3 = c2.equals(` `null` `); ` System.out.println( "is c1 equal to c2 : " + b1);
`System.out.println(` `"is c1 equal to c3 : "` `+ b2); ` System.out.println( "is c2 equal to null : " + b3);
   `` }
}
   Output:
   is c1 equal to c2 : false
   is c1 equal to c3 : true
   is c2 equal to null : false
5. final int hashCode() : This method returns a hash code for this enum constant. Actually this method contains just one statement, that is “return super.hashCode()” , which in turn calling Object class hashCode() method.
   Syntax :
   public final int hashCode()
   Parameters :
   NA
   Returns :
   a hash code for this enum constant.
   Overrides :
   hashCode in class Object
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.RED;
`System.out.print(` `"hashcode of enum constant "` `+ c1.name() +` `" : "` `); ` System.out.println(c1.hashCode());
`Color c2 = Color.GREEN; ` System.out.print( "hashcode of enum constant " + c2.name() + " : " );
`System.out.println(c2.hashCode()); ` }
}
   Output:
   hashcode of enum constant RED : 366712642
   hashcode of enum constant GREEN : 1829164700
6. final int compareTo(E obj) : This method “compares” this enum with the specified object for order. Enum constants are only comparable to other enum constants of the same enum type.
   Syntax :
   public int compareTo(E obj)
   Parameters :
   obj - the object to be compared.
   Returns :
   a negative integer if this object is at less ordinal than the specified object
   zero if this object is at equal ordinal than the specified object
   a positive integer if this object is at greater ordinal than the specified object
   Throws :
   NullPointerException - if the argument is null
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.RED;
`Color c2 = Color.GREEN; ` Color c3 = Color.RED;
`Color c4 = Color.BLUE; ` System.out.print( "Comparing " +c1.name()+ " with " + c2.name() + " : " );
`System.out.println(c1.compareTo(c2)); ` System.out.print( "Comparing " +c1.name()+ " with " + c3.name() + " : " );
`System.out.println(c1.compareTo(c3)); ` System.out.print( "Comparing " +c4.name()+ " with " + c2.name() + " : " );
`System.out.println(c4.compareTo(c2)); ` }
}
   Output:
   Comparing RED with GREEN : -1
   Comparing RED with RED : 0
   Comparing BLUE with GREEN : 1
7. static T valueOf(Class enumType,String name) : This method returns the enum constant of the specified enum type with the specified name. The name must match exactly an identifier used to declare an enum constant in this type.
   Syntax :
   public static T valueOf(Class enumType,String name)
   TypeParameters :
   T - The enum type whose constant is to be returned
   Parameters :
   enumType - the Class object of the enum type from which to return a constant
   name - the name of the constant to return
   Returns :
   the enum constant of the specified enum type with the specified name
   Throws :
   IllegalArgumentException - if the specified enum type has no
   constant with the specified name or the specified class object
   does not represent an enum type
   NullPointerException - if enumType or name is null
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`{ ` Color c1 = Color.valueOf( "RED" );
`Color c2 = Color.valueOf(` `"GREEN"` `); ` System.out.println(c1.name());
`System.out.println(c2.name()); ` }
}
   Output:
   RED
   GREEN
8. final Class getDeclaringClass() : This method returns the Class object corresponding to this enum constant’s enum type. Any Two enum constants e1 and e2 are of the same enum type if this method returns the same Class object for both.
   Syntax :
   public final Class getDeclaringClass()
   Parameters :
   NA
   Returns :
   the Class object corresponding to this enum constant's enum type
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `enum` `Day ` `{ ` MONDAY, TUESDAY ;
}
public class Test
{
`public` `static` `void` `main(String[] args) ` {
`Color c1 = Color.valueOf(` `"RED"` `); ` Color c2 = Color.valueOf( "GREEN" );
`Day d1 = Day.valueOf(` `"MONDAY"` `); ` Day d2 = Day.valueOf( "TUESDAY" );
`System.out.print(` `"Class corresponding to "` `+ c1.name() +` `" : "` `); ` System.out.println(c1.getDeclaringClass());
`System.out.print(` `"Class corresponding to "` `+ c2.name() +` `" : "` `); ` System.out.println(c2.getDeclaringClass());
`System.out.print(` `"Class corresponding to "` `+ d1.name() +` `" : "` `); ` System.out.println(d1.getDeclaringClass());
`System.out.print(` `"Class corresponding to "` `+ d2.name() +` `" : "` `); ` System.out.println(d2.getDeclaringClass());
   `` }
}
   Output:
   Class corresponding to RED : class Color
   Class corresponding to GREEN : class Color
   Class corresponding to MONDAY : class Day
   Class corresponding to TUESDAY : class Day
9. final Object clone() : This method guarantees that enums are never cloned, which is necessary to preserve their “singleton” status. It is used internally by compiler to create Enum constants.
   Syntax :
   public final Object clone() throws CloneNotSupportedException
   Parameters :
   NA
   Returns :
   NA
   Overrides :
   clone in class Object
   Throws :
   CloneNotSupportedException-if the object's class does not support the Cloneable interface.
   enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args)
`throws` `CloneNotSupportedException ` {
`System.out.println(` `"Enums are never cloned"` `); ` Test t = new Test()
`{ ` protected final Object clone()
`throws` `CloneNotSupportedException ` {
`return` `new` `CloneNotSupportedException(); ` }
`}; ` System.out.println(t.clone());
   `` }
}
   Output:
   Enums are never cloned
   java.lang.CloneNotSupportedException
10. final void finalize() : This method guarantees that enum classes cannot have finalize methods.
    Syntax :
    protected final void finalize()
    Parameters :
    NA
    Returns :
    NA
    Overrides :
    finalize in class Object
    enum Color
{
`RED, GREEN, BLUE; ` `} ` `public` `class` `Test ` `{ ` public static void main(String[] args) throws Throwable
`{ ` System.out.println( "enum classes cannot have finalize methods" );
`Test t = ` `new` `Test() ` {
`protected` `final` `void` `finalize() ` `throws` `Throwable ` {
`}; ` };
    `` }
}
    Output:
    enum classes cannot have finalize methods