代码经验---Java枚举类高阶用法

枚举类一般作为常亮定义，或者类似于map存储结构，

枚举类中定义方法或者抽象方法：

如果枚举类中定义了方法，那么可以实现，也可以不实现，

如果枚举类中定义了抽象方法，那么枚举类中的所有全部实例必须实现抽象方法。

    枚举类中可以有方法，实例可实现，也可以不实现改方法。

    枚举类中可以有抽象方法，实例必须实现；

// 场景：根据不同的参数，返回不同的对象实现
// 类似于if，else，if，else的判断

public enum TaskSequenceStrategyEnum implements IEnum {
    /**
     * 组间有序，组内有序
     */
    GROUP_SORT_AND_TASK_SORT(1) {
        @Override
        public SequenceInfo buildSequenceData() {
            return new SequenceInfo(true, true);
        }
    },
    /**
     * 组间有序，组内无序
     */
    GROUP_SORT_AND_TASK_NOSORT(2) {
        @Override
        public SequenceInfo buildSequenceData() {
            return new SequenceInfo(true, false);
        }
    },
    /**
     * 组间无序，组内有序
     */
    GROUP_NOSORT_AND_TASK_SORT(3) {
        @Override
        public SequenceInfo buildSequenceData() {
            return new SequenceInfo(false, true);
        }
    },
    /**
     * 组间无序，组内无序
     */
    GROUP_NOSORT_AND_TASK_NOSORT(4) {
        @Override
        public SequenceInfo buildSequenceData() {
            return new SequenceInfo(false, false);
        }
    },
    ;

    private final int value;

    TaskSequenceStrategyEnum(int value) {
        this.value = value;
    }

    @Override
    public int getValue() {
        return value;
    }

    @Override
    public String getName() {
        return "";
    }


    public SequenceInfo buildSequenceData() {
        throw new AbstractMethodError();
    }
}


@Data
@NoArgsConstructor
@AllArgsConstructor
public class SequenceInfo {
    /**
     * 组间的顺序
     */
    private Boolean groupNeedSequence;
    /**
     * bin task 是否需要顺序
     */
    private Boolean binNeedSequence;
}


// 业务代码中使用
// 获取枚举
int sequenceStrategy = 1;
TaskSequenceStrategyEnum strategyEnum = EnumUtils.valueOf(TaskSequenceStrategyEnum.class, sequenceStrategy);
SequenceInfo sequenceInfo = strategyEnum.buildSequenceData();

当然这里是普通方法，

也可以定义抽象方法：

    public enum AbstractWeek {
        MONDAY(0,"星期一") {
            @Override
            public AbstractWeek getNextDay() {
                return TUESDAY;
            }

        }, TUESDAY(1,"星期二") {
            @Override
            public AbstractWeek getNextDay() {
                return WEDNESDAY;
            }
        }, WEDNESDAY(2,"星期三") {
            @Override
            public AbstractWeek getNextDay() {
                return THURSDAY;
            }
        }, THURSDAY(3,"星期四") {
            @Override
            public AbstractWeek getNextDay() {
                return FRIDAY;
            }
        }, FRIDAY(4,"星期五") {
            @Override
            public AbstractWeek getNextDay() {
                return SATURDAY;
            }
        }, SATURDAY(5,"星期六") {
            @Override
            public AbstractWeek getNextDay() {
                return SUNDAY;
            }
        }, SUNDAY(6,"星期日") {
            @Override
            public AbstractWeek getNextDay() {
                return MONDAY;
            }
        };

        private int num;

        private String desc;

        AbstractWeek(int num,String desc) {
            this.num = num;
            this.desc=desc;
        }

        //一个抽象方法
        public abstract AbstractWeek getNextDay();

        public static void main(String[] args) {
            String nextDay=AbstractWeek.MONDAY.getNextDay().toString();
            System.out.println(nextDay);
        }
    }

这个抽象方法由不同的枚举值，提供了不同的实现；

这个东西其实用的比较少，

一般if，else就可以保证我们的实现了，

或者switch，case也可以实现，

总之就是根据不同的值，返回不同的实现。

 

刚好这次用了，记录下。