哪位大神能帮我写一个枚举的例子，带注释，主要体现枚举的思想就行

1. public enum TrafficLamp {
   
2.         RED(30) {
   
3.                 public TrafficLamp nextLamp() {
   
4.                         return GREEN;
   
5.                 }
   
6.         },
   
7.         GREEN(45) {
   
8.                 public TrafficLamp nextLamp() {
   
9.                         return YELLOW;
   
10.                 }
    
11.         },
    
12.         YELLOW(5) {
    
13.                 public TrafficLamp nextLamp() {
    
14.                         return RED;
    
15.                 }
    
16.         };
    
17.         int time;
    
18. 
    
19.         private TrafficLamp(int time) {
    
20.                 this.time = time;
    
21.         }
    
22. 
    
23.         public abstract TrafficLamp nextLamp();
    
24. }

复制代码

可以看看基础加强的视频，里面有详细讲解

//枚举定义星期

1. enum EnumDemo {
   
2. 星期一,
   
3. 星期二,
   
4. 星期三,
   
5. 星期四,
   
6. 星期五,
   
7. 星期六,
   
8. 星期日
   
9. }
   
10. public class Enum {
    
11. 
    
12. public static void main(String[] args) {
    
13. //得到枚举数组
    
14. EnumDemo[] en = EnumDemo.values();
    
15. 
    
16. //迭代枚举
    
17. for (EnumDemo enumDemo : en) {
    
18. switch2(enumDemo);//switch2(EnumDemo.星期一);
    
19. }
    
20. }
    
21. 
    
22. public static void switch2(EnumDemo e) {
    
23. switch (e) {
    
24. case 星期一:
    
25. System.out.println(e.toString() + "<-->" + e.ordinal());
    
26. break;
    
27. case 星期二:
    
28. System.out.println(e.toString() + "<-->" + e.ordinal());
    
29. break;
    
30. case 星期三:
    
31. System.out.println(e.toString() + "<-->" + e.ordinal());
    
32. break;
    
33. case 星期四:
    
34. System.out.println(e.toString() + "<-->" + e.ordinal());
    
35. break;
    
36. case 星期五:
    
37. System.out.println(e.toString() + "<-->" + e.ordinal());
    
38. break;
    
39. case 星期六:
    
40. System.out.println(e.toString() + "<-->" + e.ordinal());
    
41. break;
    
42. case 星期日:
    
43. System.out.println(e.toString() + "<-->" + e.ordinal());
    
44. break;
    
45. default:
    
46. break;
    
47. }
    
48. }
    
49. }

复制代码

这个是老师的经典例子，我加了我的理解，你可以认真看看，不懂继续问我。

public class EnmuTest{

        /**
         * @param args
         */
        public static void main(String[] args) throws Exception{
                // TODO Auto-generated method stub
               
                Trafficlamp trafficlamp1 =Trafficlamp.Red;
                Trafficlamp trafficlamp2= Trafficlamp.Red.nextLamp();               
               
               
                System.out.println(trafficlamp1.getTime());
                System.out.println(trafficlamp2.getTime());
               
        }
        public enum Trafficlamp{
                Red(30){//这个Red(30)其实就是父类的子类，传入构造函数30,复写父类抽象方法。可以这么理解
                        public Trafficlamp nextLamp() {
                                return Green;
                        }//new一个新对象，使用父类带构造参数的构造方法创建一个带time值为30的子类实例，对其覆写父类的抽象方法。
                },
                Yellow(5){
                        public Trafficlamp nextLamp(){
                                return Red;
                        }
                },
                Green(40){
                        public Trafficlamp nextLamp(){
                                return Red;
                        }
                };
               
                public abstract Trafficlamp nextLamp();//定义父类的抽象方法，子类都必须实现他
                private Trafficlamp(){};//父类的构造方法。子类用着个构造方法new对象
                private int time;//父类的变量
                private Trafficlamp(int time){
                        this.time=time;
                }//指定父类构造方法中带参数
                public int getTime(){
                        return time;
                }//定义一个公用的获取子类构造时的参数time
        }
       
}

没有那么复杂 其实很简单  给你个单例你看看就知道了
    单例 基础视频看完了才理解好的单例  
       class  single
      {
          private single(){}//  私有一个构造方法。
         private static single  s = new single();//私有对象.
          public static single  getInstance()//对外提供访问对象的方法.
          {
             return s ;
           }
      }
        上面代码是单例 的饿汉式  这个方法完全特别容易理解单例的好处。 所谓单例就是 给你们提供一个对象 你们所有人只能访问这个一个对象。
如果不是单例模式 访问他时候new的对象就是一个新的。就是大个比方说 ， 现在我是卖苹果的 ，你们new一个对象 我给你们一个给你一个苹果。
但是有些人呢（比如小孩 吃不完）怎么办那就简单了 用单例 你们俩只能new一个对象 也就是说只能得到一个苹果 这样你们就能共享这个苹果了。
资源共享了.
   上面写的是单例 最简单的单例就是枚举类中就一个元素。所以枚举就是一种特殊的类，其中每个元素都是该类的一个实例对象。枚举内部其实就是把一个构造方法（记住是构造方法不是构造函数）私有然后分别将每个元素分别用一个公有的静态成员变量来表示，他可以有若干个公有方法或者抽象方法。如果是构造函数话 就要把这些封装的构造函数对象放在 构造方法后面 每个构造方法一次排列在调用构造方法对象调用构造函数的时候用（）；（构造函数的排列次位 在java中是0是第一位置）
在白话些就是 枚举把一些方法封装成一个对象来表示，其实单例就是这样的。 然后可以用封装好的对象直接使用。最简单单例，格式： public enum 枚举名字{元素名字}}例：   public enum enumnume{   element }