Enum

1.Enum is a special type of classes. The enum declaration defines a class (called an enum type).
2.An enum type is a type whose fields consist of a fixed set of constants .
3.The enum class body can include methods,constructors and attributes,if we are not keeping constructor compiler will keep no args constructor.
4.All enums implicitly extend java.lang.Enum. Since Java does not support multiple inheritance, an enum cannot extend anything else.
5.enum contains only constants like c1,c2 etc.it can not have literals 10,9.7,'K',"mks",true/false etc.
6.ordinal() method can be use to find the index of enum constants which starts from 0.
7.Every enum is public & static by default.
8.General method test() can be override with any enum method by using of CSCB(constant specific class body).
-------------------------------------------------------------------------------------------------------
1)

)
enum Days 
{
	MON,TUE,WED,THU,FRI,SAT,SUN;
}
class Manager 
{
	public static void main(String[] args) 
	{
		Days d1=Days.MON;
		System.out.println(d1);
		Days d2=Days.TUE;
		System.out.println(d2);
		Days d3=Days.SUN;
		System.out.println(d3);
	}
}

/*
MON
TUE
SUN
*/
----------------------------------------------------------------------------------
2)

enum Month
{
	JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC;
}
class Manager1
{
	public static void main(String[] args) 
	{
		Month m1=Month.JAN;
		System.out.println(m1);
		m1=Month.JUL;
		System.out.println(m1);
		m1=Month.DEC;
		System.out.println(m1);
	}
}

/*
JAN
JUL
DEC
*/
----------------------------------------------------------------------------------
3)

//enum can be declare inside a class also or outside the class.
class Manager2
{
	enum A
	{
		CON1,CON2,CON3;
	}
	public static void main(String[] args) 
	{
		A a1=A.CON2;
		System.out.println(a1);
		A a2=A.CON3;
		System.out.println(a2);
	}
}

/*
CON2
CON3
*/
----------------------------------------------------------------------------------
4)

class A 
{
	enum B
	{
		C1,C2,C3;
	}
	static void test()
	{
		B b1=B.C2;
        	System.out.println(b1);
		B b2=B.C3;
        	System.out.println(b2);
	}
}
class Manager3
{
	public static void main(String[] args) 
	{
		A.B b1=A.B.C2;
		System.out.println(b1);
		A.B b2=A.B.C3;
		System.out.println(b2);
		A.test();
	}
}

/*
C2
C3
C2
C3
*/
----------------------------------------------------------------------------------
5)

//ordinal() method can be use to find the index of enum constants which starts from 0.
class Manager4 
{
	enum E
	{
		a,b,c,d;
	}
	public static void main(String[] args) 
	{
		E e1=E.a;
        	System.out.println(e1);;
		E e2=E.d;
		System.out.println(e2);
		System.out.println(e1.ordinal());
		System.out.println(e2.ordinal());
	}
}

/*
a
d
0
3
*/

----------------------------------------------------------------------------------
6)

//we can take all enum constants in an array and can print by a for loop
class Manager5
{
	enum Test
	{
		t1,t2,t3,t4,t5;
	}
	public static void main(String[] args) 
	{
		Test x[]=Test.values();
		for(int i=0;i
/*
t1
t2
t3
t4
t5
*/
----------------------------------------------------------------------------------
7)
/*valueOf is an another built in method,If valueOf(x) is not available in enum then it will compile success but give runtime error.
  it is case senstive
*/
class Manager6
{
	enum C
	{
	    X,Y,z;
	}
	public static void main(String[] args) 
	{
		C c1=C.valueOf("X");
		System.out.println(c1);
		C c2=C.valueOf("z");
		System.out.println(c2);
		C c3=C.valueOf("A");
		System.out.println(c3);
	}
}
/*
X
z
Exception in thread "main" java.lang.IllegalArgumentException: No enum const class Manager6$C.A
*/
----------------------------------------------------------------------------------
8)
/*
we can supply enum const to the switch case ,switch is keeping x1 type is X type,switch argument is enum type
*/
class Manager7
{
	enum X
	{
	    A,B,C,D;
	}
	public static void main(String[] args) 
	{
		X x1=X.C;
		switch(x1)
		{
			case A:
			{
				System.out.println("in A");
				break;
			}
			case B:
			{
				System.out.println("in B");
				break;
			}
			case C:
			{
				System.out.println("in C");
				break;
			}
			case D:
			{
				System.out.println("in D");
				break;
			}
		}
		System.out.println("Done");
	}
}
/*
in C
Done
*/
----------------------------------------------------------------------------------
9)
/*
enum constant can take any no of arguments
const sud be same name as enum*/
class Manager8
{
	enum E
	{
	    CON(90),TEST(30),JAVA(90);
		E(int i)
		{
		}
	}
	public static void main(String[] args) 
	{
		E e1=E.TEST;
		System.out.println(e1);
	}
}
/*
TEST
*/
----------------------------------------------------------------------------------
10)
/*
Every enum is public & static by default.
For every enum constant there should be suitable constructor and every constructor will execute in same order as enum have constant on creating object 
of enum..*/
class Manager9
{
	enum A
	{
	    CON,TEST(90),HELLO("ABC");

		A(int i)
		{
			System.out.println("A(int)");
		}
		A()
		{
			System.out.println("A()");
		}
		A(String s1)
		{
			System.out.println("A(String)");
		}
	}
	public static void main(String[] args) 
	{
		A a1=A.HELLO;
		System.out.println(a1);
	}
}
/*
A()
A(int)
A(String)
HELLO
*/
----------------------------------------------------------------------------------
11)
class Manager10
{
	enum Month
	{
	    JAN(31),FEB(28),MAR(31);
		int days;
		Month(int days)
		{
			this.days=days;
		}
		int getDays()
		{
			return days;
		}
	}
	public static void main(String[] args) 
	{
		Month m1=Month.FEB;
		System.out.println(m1);
		System.out.println(m1.getDays());
		System.out.println(m1.days);
		System.out.println("-------");
		Month m2=Month.JAN;
		System.out.println(m2);
		System.out.println(m2.getDays());
		System.out.println(m2.days);
		System.out.println("-------");
	}
}
/*
FEB
28
28
-------
JAN
31
31
-------
*/
----------------------------------------------------------------------------------
12)
/*
General method test() can be override with any enum method by using of CSCB.
Here for CON3 general test() method will not execute
*/
class Manager11
{
	enum A
	{
	    CON1,CON2,
		CON3
		{
			void test()//constant specific class body(CSCB)
			{
				System.out.println("CSCB-test");
			}
		},
		CON4,CON5;
		void test()
		{
			System.out.println("test");
		}
	}
	public static void main(String[] args) 
	{
		A a1=A.CON5;
		A a2=A.CON1;
		A a3=A.CON3;
		A a4=A.CON4;
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
		System.out.println(a4);
		a1.test();
		a2.test();
		a3.test();
		a4.test();
	}
}
/*
CON5
CON1
CON3
CON4
test
test
CSCB-test
test
*/