public enum Color { 
 RED, GREEN, BLANK, YELLOW 
} 
 

enum Signal {
    GREEN, YELLOW, RED
  }

  public class TrafficLight {
    Signal color = Signal.RED;

    public void change() {
      switch (color) {
      case RED:
        color = Signal.GREEN;
        break;
      case YELLOW:
        color = Signal.RED;
        break;
      case GREEN:
        color = Signal.YELLOW;
        break;
      }
    }
  }

public enum Color {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;

    // 构造方法
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }

    // 普通方法
    public static String getName(int index) {
      for (Color c : Color.values()) {
        if (c.getIndex() == index) {
          return c.name;
        }
      }
      return null;
    }

    // get set 方法
    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public int getIndex() {
      return index;
    }

    public void setIndex(int index) {
      this.index = index;
    }
  }

public class Test {
  public enum Color {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;

    // 构造方法
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }

    // 覆盖方法
    @Override
    public String toString() {
      return this.index + "_" + this.name;
    }
  }

  public static void main(String[] args) {
    System.out.println(Color.RED.toString());
  }
}

public interface Behaviour {
    void print();

    String getInfo();
  }

  public enum Color implements Behaviour {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;

    // 构造方法
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }

    // 接口方法

    @Override
    public String getInfo() {
      return this.name;
    }

    // 接口方法
    @Override
    public void print() {
      System.out.println(this.index + ":" + this.name);
    }
  }

public interface Food {
    enum Coffee implements Food {
      BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
    }

    enum Dessert implements Food {
      FRUIT, CAKE, GELATO
    }
  }

public class Light {
    /* 红灯 */
    public final static int RED = 1;

    /* 绿灯 */
    public final static int GREEN = 3;

    /* 黄灯 */
    public final static int YELLOW = 2;
  }

public enum Light {
    RED, GREEN, YELLOW;
  }

public enum Light {

  // 利用构造函数传参
  RED(1), GREEN(3), YELLOW(2);

  // 定义私有变量
  private int nCode;

  // 构造函数，枚举类型只能为私有
  private Light(int _nCode) {

    this.nCode = _nCode;

  }

  @Override
  public String toString() {

    return String.valueOf(this.nCode);

  }

}

public class LightTest {

  // 1.定义枚举类型

  public enum Light {

    // 利用构造函数传参

    RED(1), GREEN(3), YELLOW(2);

    // 定义私有变量

    private int nCode;

    // 构造函数，枚举类型只能为私有

    private Light(int _nCode) {

      this.nCode = _nCode;

    }

    @Override
    public String toString() {

      return String.valueOf(this.nCode);

    }

  }

  /**
   * 
   * @param args
   */

  public static void main(String[] args) {

    // 1.遍历枚举类型

    System.out.println("演示枚举类型的遍历 ......");

    testTraversalEnum();

    // 2.演示EnumMap对象的使用

    System.out.println("演示EnmuMap对象的使用和遍历.....");

    testEnumMap();

    // 3.演示EnmuSet的使用

    System.out.println("演示EnmuSet对象的使用和遍历.....");

    testEnumSet();

  }

  /**
   * 
   * 演示枚举类型的遍历
   */

  private static void testTraversalEnum() {

    Light[] allLight = Light.values();

    for (Light aLight : allLight) {

      System.out.println("当前灯name：" + aLight.name());

      System.out.println("当前灯ordinal：" + aLight.ordinal());

      System.out.println("当前灯：" + aLight);

    }

  }

  /**
   * 
   * 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型
   */

  private static void testEnumMap() {

    // 1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型

    EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(

    Light.class);

    currEnumMap.put(Light.RED, "红灯");

    currEnumMap.put(Light.GREEN, "绿灯");

    currEnumMap.put(Light.YELLOW, "黄灯");

    // 2.遍历对象

    for (Light aLight : Light.values()) {

      System.out.println("[key=" + aLight.name() + ",value="

      + currEnumMap.get(aLight) + "]");

    }

  }

  /**
   * 
   * 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容<BR/>
   * 
   * 可以使用allOf方法
   */

  private static void testEnumSet() {

    EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);

    for (Light aLightSetElement : currEnumSet) {

      System.out.println("当前EnumSet中数据为：" + aLightSetElement);

    }

  }

}

public class State {

public static final int ON = 1;

public static final Int OFF= 0;

}