一文相识java枚举

1. 枚举的由来

当我们知道所有变量的可能性时,只管使用枚举范例来定义,比如季节,春夏秋冬,一周(一二三四五六七),只读不必要修改
有限的一个一个列举出来的类叫做枚举类,枚举是一组常量的集合,枚举也是一个特别的类,里面包罗了一组有限的特定对象

2. 自定义实现枚举

• 不必要提供set方法,因为枚举对象值不能被修改(这里留意枚举一般只用于知道所有固定变量的值)
  
• 构造器私有化
  
• 枚举对象/属性用" final static""修饰
  
• 根据不同的类,天生不同数量的枚举对象,而且枚举对象定义全部大写
  

引用前例子

这里已知季节的所有变量是固定的春夏秋冬,可以用枚举来写

1. package EG.枚举的由来;
3.    //设置季节,春夏秋冬  
4.   
5. public class Test {  
6.     public static void main(String[] args) {  
7.         /*  
8.          * 秋autumn  
9.          * 冬winter  
10.          * */
11.         Season spring = new Season("春天","暖和");  
12.         Season summer = new Season("夏天","酷热");  
13.         Season autumn = new Season("秋天", "凉爽至极");  
14.         Season winter = new Season("冬天", "冰冷刺骨");  
15.         System.out.println(spring);  
16.   
17.     }  
18. }

复制代码

1. package EG.枚举的由来;  
2.   
3. /**  
4. * @author 简水君  
5. */  
6. public class Season {  
7.    /** 季节的名称*/  
8.     private  String name;  
9.    /** 季节的信息*/  
10.     private  String desc;  
11.   
12.   
13.     //javaBean  
14.   
15.     public Season() {  
16.     }  
17.     public Season(String name, String desc) {  
18.         this.name = name;  
19.         this.desc = desc;  
20.     }  
21.   
22.     public String getName() {  
23.         return name;  
24.     }  
25.   
26.     public void setName(String name) {  
27.         this.name = name;  
28.     }  
29.   
30.     public String getDesc() {  
31.         return desc;  
32.     }  
33.   
34.     public void setDesc(String desc) {  
35.         this.desc = desc;  
36.     }  
37.   
38.     @Override  
39.     public String toString() {  
40.         return   name+"的特点: "+desc;  
41.     }  
42. }

复制代码

引用后例子

1. package EG.枚举的由来.引用后;  
2.   
3.    //设置季节,春夏秋冬  
4.   
5. public class Test {  
6.     public static void main(String[] args) {  
7.   
8.         System.out.println(Season.SPRING);  
9.         System.out.println(Season.SUMMER);  
10.         System.out.println(Season.SPRING);  
11.         System.out.println(Season.WINTER);  
12.     }  
13. }

复制代码

这里模仿Season类继承enum类称为枚举类,其次是季节都是固定的值,不能再次创建也不能修改,将构造器私有化,把set方法删除,创建静态对象

1. package EG.枚举的由来.引用后;  
2.   
3. /**  
4. * @author 简水君  
5. */  
6. public class Season {  
7.     /**  
8.      * 季节的名称  
9.      */  
10.     private String name;  
11.     /**  
12.      * 季节的信息  
13.      */  
14.     private String desc;  
15.   
16.     //javaBean  
17.   
18.     /** 这里模拟Season类继承enum类称为枚举类 */  
19.   
20.         public final static Season SPRING = new Season("春天", "暖和");  
21.         public final static Season SUMMER = new Season("夏天", "酷热");  
22.         public final static Season AUTUMN = new Season("秋天", "凉爽至极");  
23.         public final static Season WINTER = new Season("冬天", "冰冷刺骨");
24.   
25.     private Season(String name, String desc) {  
26.         this.name = name;  
27.         this.desc = desc;  
28.     }  
29.   
30.     public String getName() {  
31.         return name;  
32.     }  
33.   
34.     public String getDesc() {  
35.         return desc;  
36.     }  
37.   
38.     @Override  
39.     public String toString() {  
40.         return name + "的特点: " + desc;  
41.     }  
42. }

复制代码

3.枚举的使用

定义枚举用名词enum ,第一行只能是常量(最终静态/类的对象的缩写),多个常量用逗号分隔,后面行随意
格式:

• 无参时:   变量名1,变量名2,变量名3; 等价于 变量n()
  
• 有参时;  变量名1(实参),变量名2(实参),变量名3(实参);
  

1. package EG.b枚举的使用;  
3. /**  
4. * @author 简水君  
5. */  
8. //设置季节,春夏秋冬  
10. public class Test {  
11.    public static void main(String[] args) {  
13.        System.out.println(Season.SPRING);  
14.        System.out.println(Season.SUMMER);  
15.        System.out.println(Season.SPRING);  
16.        System.out.println(Season.WINTER);  
18.    }  
19. }  
21. enum Season {  
22.     //这里季节都是固定的值把set方法删除  
23. /* 这里 SPRING("春天", "暖和")相当于 public final static Season SPRING = new Season("春天", "暖和");  假设有个无参常量 SPRING,也是等价于SPRING()的*/
24.    SPRING("春天", "暖和"),SUMMER("夏天", "酷热"),AUTUMN("秋天", "凉爽至极"),WINTER("冬天", "冰冷刺骨");  
26.    //javaBean  
27.    /**  
28.     * 季节的名称  
29.     */  
30.    private String name;  
31.    /**  
32.     * 季节的信息  
33.     */  
34.    private String desc;  
35.    private Season(String name, String desc) {  
36.        this.name = name;  
37.        this.desc = desc;  
38.    }  
40.    public String getName() {  
41.        return name;  
42.    }  
44.    public String getDesc() {  
45.        return desc;  
46.    }  
48.    @Override  
49.    public String toString() {  
50.        return name + "的特点: " + desc;  
51.    }  
52. }

复制代码

4.反编译enum类

这里 底层将该季节类Season为最终类,不能被继承且继承了Enum接口,有其方法values(),valueOf(),还有一个静态代码块

练习题

这里BOY,GIRL都是创建了无参的常量对象,这里输出boy指的是Boy的对象(类加载时加载一次静态最终常量),但这里没有重写Enum的toString()方法,以是指的是其常量名字,两个引用指向一个对象

5.枚举enum的方法

1. package EG.c枚举方法的使用;  
2.   
3. import java.util.Arrays;  
4.   
5. /**  
6. * @author 简水君  
7. */  
8. public class Test {  
9.     public static void main(String[] args) {  
10.         Season sp = Season.SPRING;  
11.         // 1. toString()这里返回的是枚举对象的名字 SPRING        System.out.println(sp);  
12.         // 2. name()这里返回的也是枚举对象的名字 SPRING        System.out.println(sp.name());  
13.         // 3.返回的是枚举对象的索引位置 0 , 可以用于comparable比较  
14.         System.out.println(sp.ordinal());  
15.         // 4. values() 这里返回的是一个枚举的所有常量的数组  
16.         Season[] values = Season.values();  
17.         System.out.println(Arrays.toString(values));  
18.         // for( Season s :  values ){}  
19.   
20.         // 5. valueOf(" ")获取包含字符串的常量对象  
21.         Season sa = Season.valueOf("WINTER");  
22.         System.out.println(sa);  
23.   
24.         // 6.CompareTo: 比较两个枚举常量,比较的是编号的差值,底层是两者调用ordinal方法的差值,这可以算出两个常量位置的差值  
25.         //春天和冬天的差值0-3  
26.         int i = Season.SPRING.compareTo(Season.WINTER);  
27.         System.out.println(i);  
28.   
29.     }  
30. }  
31.   
32. enum Season {  
33.     SPRING("春天", "暖和"), SUMMER("夏天", "酷热"), AUTUMN("秋天", "凉爽至极"), WINTER("冬天", "冰冷刺骨");  
34.     private String name;  
35.     private String desc;  
36.   
37.     private Season() {  
38.     }  
39.     private Season(String name, String desc) {  
40.         this.name = name;  
41.         this.desc = desc;  
42.     }  
43.   
44.     public String getName() {  
45.         return name;  
46.     }  
47.   
48.     public String getDesc() {  
49.         return desc;  
50.     }  
51.   
52. }

复制代码

例子

1. package EG.d练习题;  
2.   
3. import java.util.Arrays;  
4. import java.util.PropertyResourceBundle;  
5.   
6. /**  
7. * @author 简水君  
8. */  
9. public class Test {  
10.     public static void main(String[] args) {  
11.     //获取所有的常量数组,遍历  
12.         Week[] values = Week.values();  
13.         System.out.println("所有星期信息如下: ");  
14.         for (Week value : values) {  
15.             System.out.print(value+" ");  
16.         }  
17.     }  
18. }  
19.   
20. /**  
21. 因为我们知道一周所有变量固定的值,所以用枚举来写,而且各个变量不给改变,  
22. 而且定义的Week的是最终类,不给继承,但可以创建对象  
23. */  
24. enum Week{  
25.     MONDAY("周一"),TUESDAY("周二"),WEDNESDAY("周三"),THURSDAY("周四"),FRIDAY("周五"),SATURDAY("周六"),SUNDAY("周末");  
26.   
27.     private  String name;  
28.   
29.   
30.    private Week() {  
31.     }  
32.     private Week(String name) {  
33.         this.name = name;  
34.     }  
35.   
36.     public String getName() {  
37.         return name;  
38.     }  
39.   
40.     @Override  
41.     public String toString() {  
42.         return name;  
43.     }  
44. }

复制代码

6.枚举实现接口

• 使用enum关键字后,就不能再继承其他类了,但enum定义的类底层会继承Enum接口,这算是java的单继承机制了
  
• 枚举类和普通类一样,可以实现接口,如下形式 enum 类名 implements 接口1,接口2{} ,多几个义父
  

[code]package EG.e枚举实现接口;    public class Test {      public static void main(String[] args) {        //    调用枚举的方法          Music.GUANGHUISUIYUE.play();      }  }    enum  Music implements Play{      //定义一个音乐对象      GUANGHUISUIYUE;        @Override      public void play() {          //打印常量的名称          System.out.println("正在播放
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。