枚举enum:  特点： 枚举的直接父类 java.lang.Enum，但是不能显示继承 Enum。
枚举就相当于一个类，可以定义构造器、成员变量、普通方法和抽象方法。
默认私有的构造器，即使不写访问权限也是 private。
每个实例分别用一个全局常量表示， 枚举类的对象是固定的， 实例个数有限， 不能使用 new 关键字。
枚举实例必须位于枚举体中的最开始部分， 枚举实例列表的后要有分号与其他成员相分隔。
枚举实例后有花括号时，该实例是枚举类的匿名内部类对象。

现在来实现之定义的枚举类：
package com.itheima.study.myenum;


//定义一个 抽象类
//该类模拟枚举
 public abstract class Lamp
{
//定义变量name为了增强现实效果用于toString方法的显示
private String name;
//三个Lamp类型的常量(枚举中的属性都是public final static的)
public final static Lamp RED = new Lamp("RED"){


//实现类必须重写Lamp类中的抽象方法
@Override
void printName()
{
System.out.println("红灯");
}};
 
public final static Lamp GREEN = new Lamp("GREEN"){


@Override
void printName()
{
System.out.println("绿灯");
}};
 
public final static Lamp YELLOW= new Lamp("YELLOW"){


@Override
void printName()
{
System.out.println("黄灯");
}};
 
//构造方法私有化不能通过new关键字来生成对象。
private Lamp(String name)
{
this.name = name;
}
 
//抽象方法
abstract void printName();
//普通方法
public void print()
{
switch(name)
{
case "RED":
System.out.println("红灯停");
break;
case "GREEN":
System.out.println("绿灯行");
break;
case "YELLOW":
System.out.println("黄灯慢行");
break;    
}
}
//重写toString方法
public String toString()
{
switch(name)
{
case "RED":
return "RED";
case "GREEN":
return "GREEN";
case "YELLOW":
return "YELLOW";
   default:
    return null;
}
};


}

应用：
package com.itheima.study.myenum;


public class Client
{
public static void main(String[] args)
{
Lamp GREEN = Lamp.GREEN;
System.out.println(GREEN);
GREEN.print();
Lamp.RED.print();
Lamp.YELLOW.print();
Lamp.YELLOW.printName();
}
}

运行结果为： GREEN
绿灯行
红灯停
黄灯慢行
黄灯

现在我们来应用java为我们提供的枚举类：
以一道案例来示范
一个交通灯枚举类，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法，
并实现红灯出现5秒之后变成绿灯，绿灯3秒之后变成黄灯，黄灯2秒之后变成红灯,如此循环

灯枚举：
enum Light
{
RED("红灯")
{
//当前灯的next方法
void next()
{
//输出红灯
System.out.println(RED);
try
{
//等待5秒
Thread.sleep(5000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
//运行绿灯的next方法
GREEN.next();
}
},
GREEN("绿灯")
{
void next()
{
//输出绿灯
System.out.println(GREEN);
try
{
//等待时间
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
//执行黄灯的next方法
YELLOW.next();
}
},
YELLOW("黄灯")
{
void next()
{
//输出黄灯
System.out.println(YELLOW);
try
{
//等待时间
Thread.sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}


//执行红灯的next方法
RED.next();


}
};
String value;


//枚举的构造方法必须私有化
private Light(String value)
{
this.value = value;
}


//重写toString
public String toString()
{
return value;
}


//实现指向下一个灯，该方法为抽象方法，所以每一个枚举实例必须复写该方法
abstract void next();
}


执行类:

public class TestSix
{


public static void main(String[] args)
{ //获得绿灯枚举实例
Light green = Light.GREEN; //重绿灯开始执行
green.next();
}


}

运行结果：
绿灯
黄灯
红灯
绿灯
黄灯
红灯
绿灯

如此就实现了间隔一定时间的循环