JAVA中的枚举类：如何定义枚举类+枚举类的使用+枚举类中常用方法的介绍+一个枚举类的示例

文章目录

• • JAVA中的枚举类
  • • 1.什么是枚举类
    • 2.定义枚举类
    • 3.枚举类型在switch中的使用
    • 4.枚举类中的方法
    • 5.枚举类的构造器
    • 6.枚举类可以有成员
    • 7.枚举类也可以有抽象方法
    • 8.每个枚举类都有两个特殊的方法
    • 9.一个枚举类的小例子

      JAVA中的枚举类

      1.什么是枚举类

      枚举类型就是多例，一个类有多个实例，但是实例的个数不是无穷的，是有限的；枚举类中实例称为枚举项，一般一个枚举类不应该有太多的枚举项。

      2.定义枚举类

      使用enum关键字，例如

      public enum Direction{
      	FRONT,BEHIND,LEFT,RIGHT;
      }
      

      注意：定义枚举类型的关键字是enum，而不是Enum，所有关键字都是小写的

      其中 FRONT,BEHIND,LEFT,RIGHT 都是枚举项，它们都是本类的实例，也就是说本类只有四个对象

      在定义枚举项时，多个枚举项之间用逗号隔开，最后一个用分号结尾，如果枚举类型中只有枚举项（没有构造器、方法、变量），那么可以省略分号，但是不建议省。

      public enum Direction {
          FRONT,BEHIND,LEFT,RIGHT;
          private Direction(){
          }
          public void sleep(){
              
          }
      }
      

      3.枚举类型在switch中的使用

      在switch不能使用枚举类名称因为编译器会根据switch中d的类型来判断每个枚举类型，在case中必须直接给出与d相同类型的枚举项，而不能在有类型

      只需记住：在case中使用时不需要加类型

      public class DirectionTest {
          public static void main(String[] args) {
              Direction d = Direction.FRONT;
              System.out.println(d);
              switch (d){
                  case FRONT:  //枚举可以在switch中使用，不用写成Direction.FRONT
                      System.out.println("前");
                      break;
                  case BEHIND:
                      System.out.println("后");
                      break;
                  case LEFT:
                      System.out.println("左");
                      break;
                  case RIGHT:
                      System.out.println("右");
                      break;
              }
          }
      }
      

      4.枚举类中的方法

      所有枚举类默认都是Enum的子类，无需使用extends来继承，这说明Enum中的方法所有枚举类都拥有

      int compareTo()  //比较两个枚举项大小，其实就是比较枚举项在枚举类中声明的顺序
      boolean equals()  //比较两个枚举项是否相等
          
      int hashCod()  //返回枚举项的hashCode
          
      String name()  //返回枚举项的名称
          
      int ordinal()  //返回枚举项在枚举类中声明的序号，第一个枚举项的序号是0
      String toString()  //把枚举项转换成字符串
          
      static T valueOf(Class enumType,String name)  //把字符串转成枚举项
          
      

      compareTo()方法

      //例如FRONT下标是0，BEHIND下标是1，LEFT下标是2,RIGHT下标是3
      System.out.println(Direction.FRONT.compareTo(Direction.FRONT));  //0
      System.out.println(Direction.FRONT.compareTo(Direction.BEHIND));  //-1
      System.out.println(Direction.FRONT.compareTo(Direction.LEFT));  //-2
      System.out.println(Direction.FRONT.compareTo(Direction.RIGHT));  //-3
      

      equals()方法

      System.out.println(Direction.FRONT.equals(Direction.FRONT));  //true
      System.out.println(Direction.FRONT.equals(Direction.BEHIND));  //false
      

      name()方法

      System.out.println(Direction.FRONT.name());  //FRONT
      

      ordinal()方法

      System.out.println(Direction.FRONT.ordinal());  //0
      System.out.println(Direction.BEHIND.ordinal());  //1
      System.out.println(Direction.LEFT.ordinal());  //2
      System.out.println(Direction.RIGHT.ordinal());  //3
      

      toString()方法，变成字符串方便后续操作

      System.out.println(Direction.RIGHT.toString());  //RIGHT
      

      static T valueOf(Class enumType,String name)

      String s = "LEFT";
      Direction direction = Direction.valueOf(Direction.class,s);
      System.out.println(direction.getClass());
      //输出class com.test01.Direction
      

      5.枚举类的构造器

      枚举类也可以有构造器，构造器默认都是private修饰，而且只能是private修饰，因为枚举类实例不能让外界来创建

      其实创建枚举项就等于调用本类的无参构造器

      public enum Direction {
          FRONT,BEHIND,LEFT,RIGHT;
          private Direction(){
              System.out.println("我被调用了");
          }
          public void sleep(){
          }
      }
      

      public class DirectionTest {
          public static void main(String[] args) {
              Direction d = Direction.FRONT;
              System.out.println(d);
          }
      }
      

      输出结果：

      

      输出4遍 “我被调用了” 因为枚举类中定义了4个枚举对象

      6.枚举类可以有成员

      枚举类与正常类一样，都可以有实例变量，实例方法，静态方法等等，只不过它的实例个数是有限的

      如果Direction类只有唯一的构造器，并且是有参的构造器，那么在创建枚举项时，必须为构造器赋值

      public enum Direction {
          FRONT("aa"),BEHIND("bb"),LEFT("cc"),RIGHT("dd");
          String name;
          public String getName() {
              return name;
          }
          public void setName(String name) {
              this.name = name;
          }
          Direction(String name){
              this.name = name;
          }
          public void sleep(){
          }
      }
      

      Direction d = Direction.FRONT;
      System.out.println(d.getName());
      

      7.枚举类也可以有抽象方法

      枚举类中也可以有抽象方法，创建每个枚举项时使用“特殊”的语法实现重复抽象方法即可，也就是使用匿名内部类也就是每个枚举项都是一个枚举类的匿名子类对象

      public enum Direction {
          FRONT("aa"){
              public void func(){
                  System.out.println("aa");
              }
          },BEHIND("bb"){
              public void func(){
                  System.out.println("aa");
              }
          },LEFT("cc"){
              public void func(){
                  System.out.println("aa");
              }
          },RIGHT("dd"){
              public void func(){
                  System.out.println("aa");
              }
          };
          public abstract void func();  //只需要在方法上添加abstract关键字即可，不可以把Direction声明成抽象类
      }
      

      8.每个枚举类都有两个特殊的方法

      每个枚举类都有两个不用声明就可以调用的特殊static方法，且这两个方法不是父类中的方法

      values()返回本类中的所有枚举项

      Direction[] arr = Direction.values();
      System.out.println(Arrays.toString(arr));
      //[FRONT, BEHIND, LEFT, RIGHT]
      

      valueOf(String name)通过枚举项的名字返回所有指定枚举项，注意：这个方法跟Enum类中的valueOf()方法的参数是不同的

      Direction.valueOf("LEFT").func();
      //可以调用我们之前定义的函数func
      

      9.一个枚举类的小例子

      public enum EnumDemo {
          ONE("aa","test1",33),TOW("bb","test2",66),THREE("cc","test3",99);
          private String a;
          private String b;
          private int c;
          public String getA() {
              return a;
          }
          public void setA(String a) {
              this.a = a;
          }
          public String getB() {
              return b;
          }
          public void setB(String b) {
              this.b = b;
          }
          public int getC() {
              return c;
          }
          public void setC(int c) {
              this.c = c;
          }
          EnumDemo(String a, String b, int c) {
              this.a = a;
              this.b = b;
              this.c = c;
          }
          public String toString(){
              return "EnumDemo["+
                      "a="+a+
                      ", b="+b+
                      ", c="+c+
                      "]";
          }
          //通过a对象属性获取枚举项
          public static EnumDemo fromA(String a){
              for(EnumDemo enumDemo:EnumDemo.values()){
                  if(a.equals(enumDemo.getA())){
                      return enumDemo;
                  }
              }
              return null;
          }
          //通过枚举项名称，返回枚举项
          public static EnumDemo fromName(String name){
              try{
                  return EnumDemo.valueOf(name);
              }catch(IllegalArgumentException e){
                  System.out.println("不存在");
                  return null;
              }
          }
      }
      

      public class EnumDemoTest {
          public static void main(String[] args) {
              EnumDemo enumDemo = EnumDemo.fromA("aa");
              if(enumDemo != null){
                  System.out.println(enumDemo.toString());
              }
              EnumDemo enumDemo1 = EnumDemo.fromName("ON");
              if(enumDemo1 != null){
                  System.out.println(enumDemo1.toString());
              }
          }
      }