1，为什么要用枚举?

2，枚举是不是相当于内部类?

3,如何在主函数中使用枚举（调用？）?

4，枚举类中的都是常量，还是对象?

5 ，使用枚举的意义，难道是相互调用？

亲，最好给个实例，谢谢了！！！

它被用来将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独
一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型
可以为申明的变量提供更大的取值范围。枚举中的每个元素都是对象。枚举可以当做一个特殊类
当然也可以当做内部类使用
来看一下张老师对于枚举的例子！

1. /*
   
2. * 写一个交通灯枚举，在里面定义一个抽象方法，每个元素作为一个对象都要实现这个抽象方法
   
3. * 定义一个构造函数，每个对象都要传递一个参数
   
4. */
   
5. public class TrafficLamp {
   
6.         public static void main(String[] args) {
   
7.                 Traffic traf=Traffic.GREEN;
   
8.                        
   
9.                 System.out.println(traf.nextLamp());
   
10.                 SingleInstance sinIns=SingleInstance.Single;
    
11.                 sinIns.run();
    
12.         }
    
13. }
    
14. 
    
15. enum Traffic{
    
16.         GREEN(30){
    
17.                 public Traffic nextLamp(){
    
18.                         return YELLOW;
    
19.                 }
    
20.         },
    
21.         RED(30){
    
22.                 public Traffic nextLamp(){
    
23.                         return GREEN;
    
24.                 }
    
25.         },
    
26.         YELLOW(2){
    
27.                 public Traffic nextLamp(){
    
28.                         return RED;
    
29.                 }
    
30.         };
    
31.        
    
32.         public abstract Traffic nextLamp();
    
33.         private int time;
    
34.         private Traffic(int time){
    
35.                 this.time=time;
    
36.         }
    
37.        
    
38. }
    
39. 
    
40. //用枚举写的单例模式！
    
41.          enum SingleInstance{
    
42.                 Single(8,"Danise");
    
43.                 private final int age;
    
44.                 private final String name;
    
45.                 private SingleInstance(int age,String name){
    
46.                         this.name=name;
    
47.                         this.age=age;
    
48.                 }
    
49.                 public SingleInstance singInst(){
    
50.                         return Single ;                       
    
51.                 }
    
52.                
    
53.                 public void run(){
    
54.                         System.out.println("this is a test");
    
55.                 }
    
56.                
    
57.         }
    

复制代码

1，为什么要用枚举?
2，枚举是不是相当于内部类?
  在实际的开发中有些值只能取有限个值中的一个，例如性别：男女、季节：春夏秋冬，星期：一~日。那么我们如何在我们的java程序中体现他们呢？先抛开枚举，我们用java中普通的类来实现。如何实现呢？以季节为例，首先这个类只有四个对象春夏秋冬，不可能还有其他季节，所以我们不能让使用者创建对象（构造方法必须是私有的），那使用者如何获取季节对象呢？我们帮他提前就生成4个对象，当有需要时直接获取需要的值即可。代码如下：
class Season{
   private String name;
   private Season(String name){
     this.name = name;
   };
   public static final Season SPRINT= new Season("SPRINT");
   public static final Season SUMMER= new Season("SUMMER
   public static final Season AUTUMN= new Season("AUTUMN");
   public static final Season WINTER= new Season("WINTER");
}
在使用时：Season var = Season.WINTER;
可以说上面的代码是实现大部分"只能取有限个值中的一个"的模板，既然大部分的实现都和上面的代码类似，那么我们为什么要让开发人员做一些重复的工作呢？所以sun公司在1.5版本中推出了枚举，它替我们实现了很多代码，让我们编写代码更为轻松。将季节这个类用enum来实现代码如下：
enum Season{
SPRINT,SUMMER,AUTUMN,WINTER
}
使用一样是：Season.WINTER;它包含了上述用类来实现的全部功能，并且还有扩展比如有ordinal(),valueOf()等方法。
所以我的理解是在实际的开发中"只能取有限个值中的一个"的情况非常常见，用java 中的类来实现的话大部分的代码是差不多，为了我们开发更为快捷，推出enum让enum帮我们做大部分的代码工作。
所以第一个问题我的理解是方便我们开发，提高开发效率。第二个问题枚举和内部类没有任何关系，enum定义的实际上也是一个类我们可以查看编译后的.class文件有哪些。我感觉enum编译后的class文件的内容和我们使用类实现编译后的.class文件是差不多的。
  我觉得你会问出第二个问题可能是看视频的时候有这么一段代码：
enum TrafficLamp{
    GREEN(45){
        public TrafficLamp nextLamp(){
            return YELLOW;
        }
    }
    ,RED(30){
        public TrafficLamp nextLamp(){
            return GREEN;
        }
    },YELLOW(10){
        public TrafficLamp nextLamp(){
            return RED;
        }
    };
   
    private int time;
    private TrafficLamp(int time){
        this.time = time;
    }
    public abstract TrafficLamp nextLamp();
}
在这里实际上只是在定义枚举的时候使用到了匿名内部类而已。
GREEN(45){
        public TrafficLamp nextLamp(){
            return YELLOW;
        }
    }
这段代码你可以和下面的代码结合起来理解。
abstract class Lamp{
    public abstract Lamp nextLamp();
    public static Lamp GREEN = new Lamp(){
        public Lamp nextLamp() {
            // TODO Auto-generated method stub
            return null;
        }
        
    };
}
3,如何在主函数中使用枚举（调用？）
上面已经回答了，枚举名称.值名称
4，枚举类中的都是常量，还是对象?
既是常量也是对象，这两者并不矛盾吧！！它是对象你可以参照使用类时实现的代码，因为每个具体的值我们是不想让别人修改的，例如我们不想让上面的SPRING被修改指向了其他季节对象，如果不加上final关键字，我们就可以通过Season.SPRINT = Season.AUTUMN了，你看春季就变成秋季了，你觉得这个合理吗？加上final就避免了该问题。
5 ，使用枚举的意义，难道是相互调用？
它意义和为什么使用枚举我觉得是同一个额问题。