ENUM

Introduction

We can use enum to define a group of named constants.

Example 1

enum Month
{
JAN,FEB,MAR,……………….DEC;   //;  - ->optional
}

Example 2

enum Beer
{
 AB,AC,RC,KO;
}

• Enum concept introduced in 1.5 versions.
• When compare with old languages enum java’s enum is more powerful.
• By using enum we can define our own data types which are also come enumerated data types.

Internal implementation of enum

Internally enum’s are implemented by using class concept.
Every enum constant is a reference variable to that enum type object.
Every enum constant is implicitly public static final always.

Example 3

Diagram

Declaration and usage of enum

Example 4

enum Beer
{
 AB,AC,RC,KO;
}

class Test
{
 public static void main(String args[]) {
  Beer b1=Beer.AB;
  System.out.println(b1);
 }
}

Output:

D:\Enum>java Test
AB

Note

• Every enum constant internally static hence we can access by using “enum name”.
• Internally inside every enum toString() method is implemented to return name of the constant.

Enum vs switch statement

• Until 1.4 versions the allowed argument types for the switch statement are byte, short, char int.
• But from 1.5 version onwards in addition to this the corresponding wrapper classes and enum type also allowed.
• That is from 1.5 version onwards we can use enum type as argument to switch statement.

Diagram

Example

enum Beer
{
 AB,AC,RC,KO;
}

class Test {
 public static void main(String args[]) {
  Beer b1=Beer.RC;
  switch(b1) {
  case AB:
   System.out.println(“it is childrens brand”);
   break;
  case AC:
   System.out.println(“it is too lite”);
   break;
  case RC:
   System.out.println(“it is too hot”);
   break;
  case KO:
   System.out.println(“buy one get one”);
   break;
  default:
   System.out.println(“other brands are not good”);
  }
 }
}

Output:

D:\Enum>java Test
It is too hot

If we are passing enum type as argument to switch statement then every case label should be a valid enum constant otherwise we will get compile time error.

Example

enum Beer
{
 AB,AC,RC,KO;
}

class Test
{
 public static void main(String args[])
 {
  Beer b1=Beer.RC;
  switch(b1) {
  case AB:
  case RC:
  case RAMU:
 }
}
}

Output:

Compile time error.
D:\Enum>javac Test.java
Test.java:11: unqualified enumeration constant name required case RAMU:

We can declare enum either outside the class or within the class but not inside a method.

If we declare enum outside the class the allowed modifiers are:

public
default
strictfp.

If we declare enum inside a class then the allowed modifiers are:

public private
default + protected
strictfp static

Example

Enum vs inheritance

• Every enum in java is the direct child class of java.lang.Enum class hence it is not possible to extends any other enum.
• Every enum is implicitly final hence we can’t create child enum.
• Because of above reasons we can conclude inheritance concept is not applicable foe enum to explicitly. Hence we can’t apply extends keyword for enum’s.
• But enum can implement any no. of interface

Example

Example

java.lang.Enum class

• Every enum in java is the direct child class of java.lang.Enum class. Hence this class acts as base class for all java enums.
• It is abstract class and it is direct child class of “Object class”.
• It is implements Serializable and Comparable.

values() method:

Every enum implicitly contains a static values() method to list all constants of enum.

Example

Beer[] b=Beer.values();

ordinal() method:

Within enum the order of constants is important we can specify by its ordinal value. We can find ordinal value(index value) of enum constant by using ordinal() method.

Example

public final int ordinal();

Example

enum Beer
{
 AB,AC,RC,KO;
}
class Test{
 public static void main(String args[]) {
  Beer[] b=Beer.values();
  for(Beer b1 :b) //this is forEach loop.
  {
   System.out.println(b1+”……..”+b1.ordinal());
  }
 }
}

Output:

D:\Enum>java Test
AB……..0
AC………1
RC………2
KO………3

Speciality of java enum

when compared with old languages enum, java’s enum is more powerful because in addition to constants we can take normal variables, constructors, methods etc which may not possible in old languages. Inside enum we can declare main method and even we can invoke enum directly from the command prompt.

Example

enum Fish {
 GOLD, APOLO, STAR;
 public static void main(String args[]) {
  System.out.println(“enum main() method called”);
 }
}

Output:

D:\Enum>java Fish
enum main() method called

In addition to constants if we are taking any members like methods then the list of constants should be in the 1st line should ends with semicolon.

If we are taking any extra member then enum should contain at least one constant. Any way an empty enum is always valid.

Example

Enum vs constructor

Enum can contain constructor. Every enum constant represent an onject of that enum class which is static hence all enum constants will be created at the time of class loading automatically and hence constructor will be executed at the time of enum class loading for every enum constants.

Example

enum Beer
{
 AB,AC,RC,KO;
 Beer() {
  System.out.println(“Constructors called.”);
 }
}
class Test
{
 public static void main(String args[])
 {
  Beer b=Beer.AB;            // ----->1
  System.out.println(“hello.”);
 }
}

Output:

D:\Enum>java Test
Constructor called.
Constructor called.
Constructor called.
Constructor called.
Hello.

If we comment line 1 then the output is Hello.

We can’t create enum object explicitly and hence we can’t invoke constructor directly.

Example

enum Beer {
 AB,AC,RC,KO;
 Beer() {
  System.out.println(“constructor called”);
 }
}
class Test
{
 public static void main(String args[]) {
 Beer b=new Beer();
 System.out.println(b);
 }
}

Output:

Compile time error.
D:\Enum>javac Test.java
Test.java:9: enum types may not be instantiated
Beer b=new Beer();

Example

enum Beer
{
 AB(100), AC(70), RC(65), KO(90), RAMU;
 int price;
 Beer(int price) {
  this.price=price;
 }
 Beer()
 {
  this.price=125;
 }
 public int getPrice()
 {
  return price;
 }
}
class Test{
 public static void main(String args[])
 {
  Beer[] b=Beer.values();
  for(Beer b1.b)
  {
   System.out.println(b1+”………..”+b1.getPrice());
  }
 }
}

Output:

AB……………100
AC…………….70
RC…………….65
KO…………….90
RAMU………….125

Inside enum we can take both instance and static methods but it is not possible to take abstract methods.

Case 1:

Every enum constant represents an object hence whatever the methods we can apply on the normal objects we can apply the same methods on enum constants also.

Which of the following expressions are valid?

Beer.AB==Beer.RC--------------------->false
Beer.AB.equals(Beer.RC)-------------------->false
Beer.AB < Beer.RC------------------------>invalid
Beer.AB.ordinal() < Beer.RC.ordinal()---------->valid

Case 2:

Example 1:

package pack1;
public enum Fish
{
 STAR,GUPPY;
}

Example 2:

package pack2;
//import static pack1.Fish.*;
import static pack1.Fish.STAR;
class A
{
 public static void main(String args[]) {
  System.out.println(STAR);
 }
}

Import pack1.*; ---------------------->invalid
Import pack1.Fish; -------------------------->invalid
Import static pack1.Fish.*; ------------------------>valid
Import static pack1.Fish.STAR; --------------------------->valid

Example 3:

package pack3;
//import pack1.Fish;
import pack1.*;
//import static pack1.Fish.GUPPY;
import static pack1.Fish.*;
class B
{
 public static void main(String args[]) {
  Fish f=Fish.STAR;
  System.out.println(GUPPY);
 }
}

Note

If we want to use classname directly from outside package we should write normal import, if we want to access static method or static variable without classname directly then static import is required.

Case 3:

Example 1:

enum Color
{
 RED,BLUE,YELLOW;
 public void info()
 {
  System.out.println(“Universal color”);
 }
}
class Test
{
 public static void main(String args[])
 {
  Color[] c=Color.values();
  for(Color c1 : c)
 {
 c1.info();
 }
 }
}

Output:

Universal color
Universal color
Universal color

Example 2:

enum Color
{
 RED,BLUE;
{
public void info()
{
 System.out.println(“Dangerous color”);
}
} ,YELLOW;
 public void info()
{
 System.out.println(“Universal color”);
}
}
class Test
{
 public static void main(String args[])
 {
  Color[] c=Color.values();
  for(Color c1 : c)
  {
   c1.info();
  }
 }
}

Output:

Universal color
Dangerous color
Universal color

enum Vs Enum Vs Enumeration

enum:

enum is a keyword which can be used to define a group of named constants.

Enum

It is a class present in java.lang package.
Every enum in java is the direct child class of this class. Hence this Enum class acts as base class for all java enum’s.

Enumeration

It is a interface present in java.util package.
We can use Enumeration to get the object one by one from the Collections.

Java Collections
Java Path and ClassPath setup
Jave Streams
Method and Constructor in Java
Tomcat port already in use


Thanks for reading. If you like this post please follow us for more updates about technology related updates.