聊一聊Java的枚举enum

2019-08-09 00:00:00 java 枚举 聊一聊

一. 什么是枚举

枚举是一种数据类型,具有集合的一些特点,可以存放多个元素,但存储对象有限且固定,枚举也有比较常见的使用场景,如我们需要表达性别(男、女),颜色(红、黄、蓝),星期(星期一、星期二…星期日),四季(春、夏、秋、冬),地理位置(东、西、南、北),方向(前、后、左、右)等,这些场景都非常适合枚举。

二. 定义枚举

java中使用enum来定义枚举,和class,interface具有同样的等级,(注意是enum,而不是Enum),定义枚举可以有两种情况

第一种:默认构造器(空构造器)

public enum Quarter {
    SPRING, SUMMER, AUTUMN, WINTER;
}

未定义成员变量和成员方法,省略了private Quarter() {}

public enum Quarter {
    SPRING, SUMMER, AUTUMN, WINTER;
    private Quarter(){}
}

简单说明一下:枚举enum的构造器只能是private

第二种:定义了成员变量、带参构造器

枚举可以定义成员变量,包括成员属性、方法,抽象方法,静态方法等

public enum Quarter {
    SPRING("春"), SUMMER("夏"), AUTUMN("秋"), WINTER("冬");

    private Quarter(String name){
        this.name = name;
    }
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //静态方法
    public static void printName(){
        System.out.println(Quarter.SUMMER);
    }
    
    //抽象方法
    public abstract void printValue();
}

注意:枚举和类一样,可以有多个构造器,即有了一个带参构造器,还可以有无参构造器,编译是可以通过的。

除此之外:

  1. 枚举enum 默认继承了java.lang.Enum类,实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口,可序列化以及进行比较;
  2. 所有的枚举值都是常量,默认采用了public static final 进行了修饰,enum不是类,自然也不能被继承或实现;
  3. 枚举值必须在第一行,否则编译出错;

三. 枚举常见用法

1. 获取枚举元素以及成员变量

public static void main(String[] args) {
    //获取枚举元素
    System.out.println(Quarter.SPRING);
    //调用toString()方法将枚举元素转化为String类型
    System.out.println(Quarter.SPRING.name());
    System.out.println(Quarter.SPRING.toString());
    //获取成员变量
    System.out.println(Quarter.SPRING.getName());
}

输出结果:

SPRING
SPRING
SPRING
春

2. 枚举遍历

有时候我们需要将枚举元素都取出来作为查询条件,此时就需要进行遍历,通过调用Quarter.values()方法

public static void main(String[] args) {
    //通过values()方法得到Quarter元素的数组
    Quarter[] quarters = Quarter.values();
    List<String> quarterParam = new ArrayList<>(quarters.length);
    //将数组中的元素存储到List集合quarterParam中
    for (Quarter quarter : quarters) {
        quarterParam.add(quarter.toString());
    }
}

3. switch条件判断

枚举的元素有限且固定,通过switch做条件判断却是正好

public static void main(String[] args){
    Quarter quarter = Quarter.AUTUMN;
    switch (quarter) {
        case SPRING:
            System.out.println("找到了,是它:" + SPRING);
            break;
        case SUMMER:
            System.out.println("找到了,是它:" + SUMMER);
            break;
        case AUTUMN:
            System.out.println("找到了,是它:" + AUTUMN);
            break;
        case WINTER:
            System.out.println("找到了,是它:" + WINTER);
            break;
        default:
            System.out.println("未找到");
            break;
    }
}

执行后结果:

找到了,是它:AUTUMN

简单说明一下:其实此处不需要default的内容,或者说将WINTER作为default即可,因为枚举天然有类型限制,你只能传递它已有的元素以及null,不过正常情况下都会提前判断传递的参数是否为null,当switch接收到null时会报java.lang.NullPointerException。

4. 枚举比较

4.1. 判断是否相等

枚举判断两个元素是否相等直接使用==进行判断即可,因为它非类,也无法实例化,存储位置自然也不会根据对象的不同而不同。

public static void main(String[] args){
    System.out.println(Quarter.AUTUMN == Quarter.AUTUMN);
    System.out.println(Quarter.AUTUMN == Quarter.WINTER);
}

执行结果:

true
false

也可以通过equals()方法进行比较,不过没必要,因为其底层也是通过 == 来实现的。

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
    //equals比较
    public final boolean equals(Object other) {
        return this==other;
    }
}

4.2. 顺序比较

通过compareTo进行枚举元素比较,此处比较的是在枚举中元素的先后顺序,返回的是位置序数的差值

public static void main(String[] args){
    System.out.println(Quarter.AUTUMN.compareTo(Quarter.SPRING));
    System.out.println(Quarter.AUTUMN.compareTo(Quarter.WINTER));
}

执行结果为:

2
-1

我们看一下compareTo方法

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
    //元素在枚举中的序号
    private final int ordinal;
    //可以看到compareTo方法返回的就是两个元素ordinal的差值
    public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() &&
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }
}

5. 枚举也可也实现接口

public interface WeatherInterface {
    //获取温度
    public String getTemperature(Quarter quarter);
}
public enum Quarter implements WeatherInterface{
    SPRING("春"), SUMMER("夏"), AUTUMN("秋"), WINTER("冬");
    
    private Quarter(String name){
        this.name = name;
    }

    private String name;

    public String getName() {
        return name;
    }
    //重写获取温度方法
    @Override
    public String getTemperature(Quarter quarter) {
        switch (quarter) {
            case SPRING:
                return "适中";
            case SUMMER:
                return "热";
            case AUTUMN:
                return "凉爽";
            case WINTER:
                return "寒冷";
            default:
                return "无法确定";
        }
    }
}

但注意枚举不可继承其他类

public class Pquarter {}
//无法编译通过
public enum Quarter extends Pquarter {}

6. 使用接口来组织枚举

如果枚举太多也不好管理,同时条理不够清晰,我们可以通过接口来将多个相关枚举组织在一起进行管理,

public interface Weather {
    enum Quarter implements Weather {
        SPRING, SUMMER, AUTUMN, WINTER;
    }
    enum Temperature implements Weather {
        MODERATE, HEAT, COOL, COLD
    }
    //调用时直接通过Weather.Quarter.SPRING即可。
}

四. 总结

本文主要介绍了枚举enum主要特点,定义,无参构造器,有参构造器,枚举的常用方法举例以及主要的应用场景,若有不对之处,请批评指正,望共同进步,谢谢!

相关文章