java enum enumeration

　In most programming languages, enumeration types will be a commonly used and essential data type, and Java is certainly no exception. However, the Enum enumeration type in Java has many unexpected uses. Let's take a look.

1. You can add variables and methods to enum

Let’s first look at a code example:

public enum State {
        Normal("正常态", 1), Update("已更新", 2), Deleted("已删除", 3), Fired("已屏蔽", 4);
        // 成员变量
        private String name;
        private int index;
 
        // 构造方法，注意：构造方法不能为public，因为enum并不可以被实例化
        private State(String name, int index) {
            this.name = name;
            this.index = index;
        }
 
        // 普通方法
        public static String getName(int index) {
            for (State c : State .values()) {
                if (c.getIndex() == index) {
                    return c.name;
                }
            }
            return null;
        }
 
        // get set 方法
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
 
        public int getIndex() {
            return index;
        }
 
        public void setIndex(int index) {
            this.index = index;
        }
    }

From the above code, we can see that after defining the enumeration value, add a semicolon after it, and then You can define other variables and methods. In addition, it should be noted that the constructor in enum cannot be marked as public. This is to prevent users from instantiating enum.

　2. Can be used to define constants

Let’s first review how to define constants in Java. Look at the following code:

public static final int normalState = 1;
private static final int updateState = 2;

Next, we can also use enum enumeration to replace the above constant definition. The code is as follows:

public enum State { 
  Normal, Update, Deleted, Fired
}

There is no syntactic advantage in using enum to define constants in Java, but the enum enumeration type can provide more operation functions.

　3. Implement the interface in enum

Let’s first look at the following piece of code:

public interface ICanReadState {
        void read();
 
        String getState();
}
 
    public enum State implements ICanReadState {
        Normal("正常态", 1), Update("已更新", 2), Deleted("已删除", 3), Fired("已屏蔽", 4);
 
        private String name;
        private int index;
 
        private State(String name, int index) {
            this.name = name;
            this.index = index;
        }
 
        // 接口方法1
 
        @Override
        public String getState() {
            return this.name;
        }
 
        // 接口方法2
        @Override
        public void read() {
            System.out.println(this.index + ":" + this.name);
        }
    }

Just like using interfaces in general classes, enums can also inherit interfaces and implement all methods in the interface. This is how The advantage is that it is easier to sort, compare and other operations on the values ​​in the enumeration, and has better encapsulation.

Summary

To put it bluntly, the enum enumeration type is a final class that cannot be inherited. Take the State enumeration above as an example. If you look at the bytecode of the enum type, it is actually a class static constant of the State type. .