【JavaSE】枚举

尚硅谷JavaSE笔记合集

文章名	链接
【JavaSE】异常	文章地址
【JavaSE】常用类：String、LocalDateTime…	文章地址
【JavaSE】枚举	文章地址
【JavaSE】注解	文章地址
【JavaSE】集合框架	文章地址 | HashMap源码解析 | List相关实现类源码解析
【JavaSE】泛型	文章地址
【JavaSE】IO流	文章地址 | 字符编码详解
【JavaSE】网络编程，BIO需求演进	文章地址
【JavaSE】反射	文章地址
【JavaSE】jdk8新特性	文章地址

一、枚举类的理解

• 类的对象只有有限个，确定的。举例如下：

• 当需要定义一组常量时，强烈建议使用枚举类：相当于每个枚举对象只保留对象名

• 枚举类的实现

  • JDK1.5之前需要自定义枚举类
  • JDK 1.5 新增的enum 关键字用于定义枚举类

• 当需要使用单例模式时，强烈建议使用枚举类：定义内部枚举类只有一个枚举对象，该对象的变量为外部类对象。

  final class SingleEnum{
      private SingleEnum(){}
      public static final SingleEnum getInstance(){
          return SingleEnumDemo.INSTANCE.getInstance();
      }
      private enum SingleEnumDemo{
          INSTANCE;
          private final SingleEnum singleEnum;
          SingleEnumDemo(){
              singleEnum=new SingleEnum();
          }
          public final SingleEnum getInstance(){
              return singleEnum;
          }
      }
  }
  

二、自定义枚举类

• 属性不应允许被改动, 所以应该使用private final 修饰
• 使用private final 修饰的属性应该在构造器中为其赋值
• 若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的传入参数

/**
 * 不使用enum关键字自定义枚举类
 */
public class Season1 {
    public static void main(String[] args) {
        Season1 season=Season1.SPRING;
        System.out.println(season);
    }
    //1.声明每个对象的季节名字属性
    private final String NAME;
    //2.声明每个对象的季节描述属性
    private final String DECRIBE;
    //3.私有化构造器，保证有限个对象
    private Season1(String name,String decribe){
        this.NAME=name;
        this.DECRIBE=decribe;
    }

    //4.定义当前类的有限个不同对象
    public static final Season1 SPRING=new Season1("春天","春暖花开");
    public static final Season1 SUMMER=new Season1("夏天","夏日炎炎");
    public static final Season1 AUTUMN=new Season1("秋天","秋高气爽");
    public static final Season1 WINTER=new Season1("冬天","冰天雪地");

    //5.其他诉求
    public String getNAME() {
        return NAME;
    }
    public String getDECRIBE() {
        return DECRIBE;
    }
    @Override
    public String toString() {
        return "Season{" +
                "NAME='" + NAME + '\'' +
                ", DECRIBE='" + DECRIBE + '\'' +
                '}';
    }
}

三、enum定义枚举类

• 默认继承了java.lang.Enum类，因此不能再继承其他类
• 枚举类的构造器只能使用private 权限修饰符
• 枚举类的所有实例必须在枚举类中显式列出(, 分隔; 结尾)。列出的实例系统会自动添加public static final 修饰
• 必须在枚举类的第一行声明枚举类对象

/**
 * 使用enum关键字定义枚举类
 * 说明：定义的枚举类默认继承于java.lang.Enum类
 */
public enum Season2 {
    //4.定义当前类的有限个不同对象
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //1.声明每个对象的季节名字属性
    private final String NAME;
    //2.声明每个对象的季节描述属性
    private final String DECRIBE;
    //3.私有化构造器，保证有限个对象
    private Season2(String name,String decribe){
        this.NAME=name;
        this.DECRIBE=decribe;
    }

    //5.其他诉求
    public String getNAME() {
        return NAME;
    }
    public String getDECRIBE() {
        return DECRIBE;
    }
//    @Override
//    public String toString() {
//        return "Season{" +
//                "NAME='" + NAME + '\'' +
//                ", DECRIBE='" + DECRIBE + '\'' +
//                '}';
//    }
}

四、Enum类常用方法

• valueOf(String str)：类方法
  • 返回对象名与参数str一样的枚举对象。不存在则抛运行时异常：IllegalArgumentException
• values()：类方法
  • 返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
• toString()：实例方法
  • 返回当前枚举类对象对应的变量名

System.out.println("=======================valueOf()============================");
Season2 season2 = Season2.valueOf("SPRING");
System.out.println(season2);
System.out.println("=======================values()============================");
Season2[] values = Season2.values();
   for (Season2 value : values) {
       System.out.println(value);
}
System.out.println("=======================toString()============================");
   System.out.println(season2.toString());

五、枚举类实现接口

• 情况一：实现接口，在enum类中实现抽象方法

• 情况二：让枚举类的对象分别实现接口中的抽象方法

public class EnumAndInterface {
    public static void main(String[] args) {
        Season3 spring=Season3.SPRING;
        spring.selfIntroduction();
        Season3 summer=Season3.SUMMER;
        summer.selfIntroduction();
    }
}
interface Season{
    void selfIntroduction();
}
enum Season3 implements Season{
    //4.定义当前类的有限个不同对象
    SPRING("春天","春暖花开"){
        @Override
        public void selfIntroduction() {
            System.out.println("我是春天");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void selfIntroduction() {
            System.out.println("我是夏天");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void selfIntroduction() {
            System.out.println("我是秋天");
        }
    },
    WINTER("冬天","冰天雪地"){
        @Override
        public void selfIntroduction() {
            System.out.println("我是冬天");
        }
    };

    //1.声明每个对象的季节名字属性
    private final String NAME;
    //2.声明每个对象的季节描述属性
    private final String DECRIBE;
    //3.私有化构造器，保证有限个对象
    private Season3(String name,String decribe){
        this.NAME=name;
        this.DECRIBE=decribe;
    }

    //5.其他诉求
    public String getNAME() {
        return NAME;
    }
    public String getDECRIBE() {
        return DECRIBE;
    }
//    @Override
//    public String toString() {
//        return "Season{" +
//                "NAME='" + NAME + '\'' +
//                ", DECRIBE='" + DECRIBE + '\'' +
//                '}';
//    }
}

六、Switch中枚举类的使用

• switch 枚举对象
• case 枚举对象对应的变量名

Season3 season=Season3.AUTUMN;
switch (season){
   case SPRING:
       System.out.println("我是春天");break;
   case SUMMER:
       System.out.println("我是夏天");break;
   case AUTUMN:
       System.out.println("我是秋天");break;
   case WINTER:
       System.out.println("我是冬天");break;
}