实例有限而且固定的类，在java里称为枚举类。

手动实现枚举类：

  1. public class Season 
  2. { 
  3.     private final String name; 
  4.     private final String desc; 
  5.     public static final Season SPRING = new Season("春天","趁青踏青"); 
  6.     public static final Season SUMMER = new Season("夏天","下日炎炎"); 
  7.     public static final Season FALL = new Season("秋天","秋高气爽"); 
  8.     public static final Season WINTER = new Season("冬天","围炉赏雪"); 
  9.     public static Season getSeason(int seasonNum) 
  10.     { 
  11.         switch(seansonNum) 
  12.         { 
  13.             case 1:return SPRING;    
  14.             case 2:return SUMMER;    
  15.             case 3:return FALL;  
  16.             case 4:return WINTER;    
  17.             default: return null; 
  18.         }    
  19.     }        
  20.     //将构造器定义成private访问权限 
  21.     private Season(String name,String desc) 
  22.     { 
  23.         this.name = name; 
  24.         this.desc = desc;    
  25.     } 
  26.     //只为name 和 desc 提供getter方法 
  27.     public String getName() 
  28.     { 
  29.         return name;     
  30.     } 
  31.     public String getDesc() 
  32.     { 
  33.         return desc;     
  34.     } 
  35. } 
  36. class SeasonTest 
  37. { 
  38.     public SeasonTest(Season s) 
  39.     { 
  40.         System.out.println(s.getName()+",这真是一个"+ s.getDesc()+"的季节"); 
  41.     }    
  42.     public static void main(String[] args) 
  43.     { 
  44.         //直接使用Season的FALl常量代表一个Season对象 
  45.         new SeasonTest(Season.FALL);     
  46.     } 
  47. } 


枚举类入门：


  1. /* 
  2.     枚举类继承的不是Object类而是Enum类 
  3.     非抽象的枚举类默认使用final修饰，抽象的由abstract修饰
  4.     枚举类的构造器默认private 
  5.     枚举类的所有实例必须在枚举类的第一行显式列出，且默认public static final修饰 
  6. */ 
  7. enum SeasonEnum 
  8. { 
  9.     //在第一行列出4个枚举实例   
  10.     SPRING,SUMMER,FALL,WINTER;//如果使用实例，则使用SeasonEnum.SPRING 
  11. } 
  12. public class EnumTest 
  13. { 
  14.     public void judge(SeasonEnum s) 
  15.     { 
  16.         //switch语句里的表达式可以是枚举类 
  17.         switch(s) 
  18.         { 
  19.             case SPRING:System.out.println("春暖花开，正好踏青");    break; 
  20.             case SUMMER:System.out.println("夏日炎炎，适合游泳");    break; 
  21.             case FALL:System.out.println("秋高气爽，进补及时");  break; 
  22.             case WINTER:System.out.println("冬日雪飘，围炉赏雪");    break; 
  23.         }    
  24.     } 
  25.     public static void main(String[] args) 
  26.     { 
  27.         //所有枚举类都有一个values方法，返回该枚举类的所有实例 
  28.         for(SeasonEnum s : SeasonEnum.values()) 
  29.         { 
  30.             System.out.println(s);   
  31.         } 
  32.         new EnumTest().judge(SeasonEnum.SPRING); 
  33.     } 
  34. } 


 switch的扩展：


switch的控制表达式可以是任何枚举类型，当switch控制表达式使用枚举类型时，后面case表达式中的值直接使用枚举值的名字，无需添加枚举类做限定。


枚举类的方法，Field，构造器


 


  1. enum Gender 
  2. { 
  3.     MALE,FEMALE; 
  4.     //定义一个public修饰的实例变量 
  5.     private String name;     
  6.     public void setName(String name) 
  7.     { 
  8.         switch(this) 
  9.         { 
  10.             case MALE: 
  11.             if(name.equals("男")) 
  12.             { 
  13.                 this.name = name;    
  14.             }    
  15.             else 
  16.             { 
  17.                 System.out.println("参数错误"); 
  18.                 return;  
  19.             } 
  20.             break; 
  21.             case FEMALE: 
  22.             if(name.equals("女")) 
  23.             { 
  24.                 this.name = name;    
  25.             }    
  26.             else 
  27.             { 
  28.                 System.out.println("参数错误"); 
  29.                 return;  
  30.             } 
  31.             break; 
  32.         }    
  33.     } 
  34.     public String getName() 
  35.     { 
  36.         return this.name;    
  37.     } 
  38. } 
  39. public class GenderTest 
  40. { 
  41.     public static void main(String[] args) 
  42.     { 
  43.         //通过Enum的valueOf方法来获取指定枚举类的枚举值 
  44.         Gender g = Enum.valueOf(Gender.class ,"FEMALE"); 
  45.          
  46.         g.setName("女"); 
  47.          
  48.         System.out.println(g + "代表："+ g.getName());  
  49.          
  50.         g.setName("男");//提示参数错误 
  51.          
  52.         System.out.println(g + "代表："+ g.getName());  
  53.     }    
  54. } 


因为我们将所有的Field都使用final修饰，所以必须在构造器中为这些Field指定初始值，为枚举类显示定义带参数的构造器：


 


  1. public enum Gender 
  2. { 
  3.     MALE("男"),FEMALE("女"); 
  4.     private final String name; 
  5.     //枚举类的构造器只能使用private修饰 
  6.     private Gender(String name) 
  7.     { 
  8.             this.name = name; 
  9.     } 
  10.     public String getName() 
  11.     { 
  12.         return this.name;    
  13.     } 
  14. } 


上面的编辑代码等于：


 


  1. public static final Gender MALE = new Gender("男"); 
  2. public static final Gender MALE = new Gender("女");