Learn how enumerations can be utilized in Java.<\/b>
Enumeration is a recent (from JDK5) inclusion into the family of Java APIs. It basically represents a list of named constants. Apart from Java, almost all other prominent programming languages have the feature of enumeration. Although Java has the final keyword to represent constants, enumeration was included as a convenience to meet many of the streamlined needs of the programmer. This article tries to provide the background information and show how enumerations can be utilized in Java.
Unlike the features of enumeration in other languages, the enumeration designated by the keyword enum in Java represents a special type of class. This inherent capability bolstered the principle of expansion in Java. Because it is a class type, it has a constructor, methods, and instance variables associated with it.
The values defined by the enum are constant. This means they are implicitly static and final. It is not possible to change the values after declaration. The enum is ideally used to represent a set of fixed named constants. For example, to enumerate a list of gender varieties, we may write:
The identifiers Male , Female , and Third are called enumeration constants. As stated earlier, they are by default public static and final members of the enum class. These constants declared are of self typed. We can declare a enum variable as
and can assign a value as
We also can use a comparison operator as such:
Or, use it with the switch statements, as in this example:
Observe that we have not used any qualifier, such as Gender. Male , with the case statement; instead, we used only the named constant Male. This is possible because, when we have declared gender with the switch , statement it implicitly recognizes the type of the enum constants.
We can specify custom values with enum constants at the time of declaration. In the following code, we have specified some values. But, to actualize this principle, we must declare a private member variable and a private constructor.
Because the Enum class implements the Comparable interface, the use of compareTo() is its inherent capability. Moreover, the Java compiler automatically creates a static method, called values() , which returns an array of named constants defined in the enum. There is another static method, called valueOf() , which takes enum class types and the named constant in the string format. This method returns the enumeration constant of the value that corresponds to the string passed in the parameter. We can use them in the following manner:
Although Java enumeration is of the class type , we do not use the new keyword to instantiate it. The association of a class as its principle design gives it some extraordinary capability. It can be used like any other normal classes in Java. We can declare a constructor, define member variables and methods, and even implement an interface. When we create an enumeration constant, an object of that type actually is created. When the constructor is invoked, the enumeration constants are initialized. This also means that each enumeration object has its own copy of its member variables defined by it. Therefore, it can be said that following two enumeration declarations are quite distinct.
An enum class can inherit from a super class or implement a super interface. Following is a perfectly valid declaration:
However, all enumeration classes automatically inherit java.lang. Enum. As a result, the methods declared in java.lang. Enum are all available to the enum delaration.
The java.lang. Enum does not have a public constructor. The method declared in this class is compareTo() due to the implementation of the Comparable interface, clone() , hashCode() , toString() , and equals() due to the inheritance of the Object class. Other member methods declared are as follows:
Output:
It is possible to define an abstract class within enum as follows:
Enumeration can be used in many ways. What you’ve seen here is another versatile feature of Java. This capability can be worked up to use according to the need of the programmer. The idea is to treat enumeration like a special class that defines a list of named constants. So, without using several final static variables to declare a collection of constants, we can use enumeration. The goal is to provide readability, conceptual purity, and ease of use.<\/p>\n