枚举

1.枚举

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static final…. 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

Java代码

public enum Color {  
  RED, GREEN, BLANK, YELLOW 
  }

---

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

Java代码

public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.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;  
    }  
    }

---

https://blog.csdn.net/qq_27093465/article/details/52180865

https://www.cnblogs.com/sister/p/4700702.html

1.values()获取存储枚举中所有常量实例的数组。常配合foreach完成遍历

for(ColorEnum temp:ColorEnum.values()){
        System.out.println(temp);
}

　　运行结果：

　　RED
　　GREEN
　　BLUE

　　2.构造方法，枚举的构造方法只能用private修饰符修饰，原因就不需要解释了……

　　3.valueOf()通过常量名获取对应的枚举实例。

　　ColorEnum red = ColorEnum.valueOf("RED");
　　System.out.println(red);

---

//枚举类的后缀建议为Enum，枚举类型的实例对象建议全大写（这样做符合JAVA的规范
//当我们创建SeasonEnum这个枚举类时，
// 可不可以让SeasonEnum中的每一个实例对象都有一个getChinese()方法呢。\
// 答案是肯定的，而且这种做法在企业开发中很常见。
public enum SeasonEnum {
    SPRING("春天"), SUMMER("夏天"), AUTUMN("秋天"), WINTER("冬天");

//    这样乍一看是不是有点像我们平时创建一般实体类一样。
//    其实枚举类型可以看做我们平时新建.class差不多，
//    只是枚举类限制了此类的实例对象
//     当然，枚举类可以有自己的成员变量和方法。
//    上面的SeasonEnum 枚举类有了chinese这个成员变量，
//    所以我们在定义实例对象时就要维护这个chinese成员变量。
//    现在再来看看，我们是怎么使用这个枚举类简化我们的代码

    private String chinese;

    SeasonEnum(String chinese) {
        this.chinese = chinese;
    }

    public String getChinese() {
        return chinese;
    }


}

public class Test {
    public static void main(String[] args) {

        SeasonEnum spring = SeasonEnum.SPRING;

        System.out.println(spring.getChinese());

    }
}

https://blog.csdn.net/cauchy6317/article/details/82313088

---

public enum Weekday {
    SUN(0),MON(1),TUS(2),WED(3),THU(4),FRI(5),SAT(6);

    private int value;

    private Weekday(int value){
        this.value = value;
    }

    public static Weekday getNextDay(Weekday nowDay){
        int nextDayValue = nowDay.value;

        if (++nextDayValue == 7){
            nextDayValue =0;
        }

        return getWeekdayByValue(nextDayValue);
    }
//重要的代码段
    public static Weekday getWeekdayByValue(int value) {
        for (Weekday c : Weekday.values()) {
            if (c.value == value) {
                return c;
            }
        }
        return null;
    }
}

class Test2{
    public static void main(String[] args) {
        System.out.println("nowday ====> " + Weekday.SAT);
        System.out.println("nowday int ====> " + Weekday.SAT.ordinal());
        System.out.println("nextday ====> " + Weekday.getNextDay(Weekday.SAT)); // 输出 SUN

        //输出：
        //nowday ====> SAT
        //nowday int ====> 6
        //nextday ====> SUN
    }
}
 这样就完成了我们的目标，和之前的代码比起来，有没有觉得突然高大上了许多？没有那么多烦人的ifelse，世界都清净了。

好了，现在你大概知道为什么要引入枚举类了吧？就是因为在没有枚举类的时候，我们要定义一个有限的序列，比如星期几，男人女人，春夏秋冬，一般会通过上面那种静态变量的形式，但是使用那样的形式如果需要一些其他的功能，需要些很多奇奇怪怪的代码。所以，枚举类的出现，就是为了简化这种操作

Weekday可以调用的方法和参数。发现它有两个方法：value()和valueOf()。还有我们刚刚定义的七个变量。

这些事枚举变量的方法。我们接下来会演示几个比较重要的：

public enum Weekday {
SUN,MON,TUS,WED,THU,FRI,SAT
}

class Test3{
public static void main(String[] args) {
System.out.println(Weekday.valueOf(“mon”.toUpperCase()));
//MON

    for (Weekday w : Weekday.values()){
        System.out.println(w + ".ordinal()  ====>" +w.ordinal());
    }
    //SUN.ordinal()  ====>0
    //MON.ordinal()  ====>1
    //TUS.ordinal()  ====>2
    //WED.ordinal()  ====>3
    //THU.ordinal()  ====>4
    //FRI.ordinal()  ====>5
    //SAT.ordinal()  ====>6

    System.out.println("Weekday.MON.compareTo(Weekday.FRI) ===> " + Weekday.MON.compareTo(Weekday.FRI));
    System.out.println("Weekday.MON.compareTo(Weekday.MON) ===> " + Weekday.MON.compareTo(Weekday.MON));
    System.out.println("Weekday.MON.compareTo(Weekday.SUM) ===> " + Weekday.MON.compareTo(Weekday.SUN));
    //Weekday.MON.compareTo(Weekday.FRI) ===> -4
    //Weekday.MON.compareTo(Weekday.MON) ===> 0
    //Weekday.MON.compareTo(Weekday.SUM) ===> 1

    System.out.println("Weekday.MON.name() ====> " + Weekday.MON.name());
    //Weekday.MON.name() ====> MON

}

---

Weekday.valueOf() 方法：

它的作用是传来一个字符串，然后将它转变为对应的枚举变量。前提是你传的字符串和定义枚举变量的字符串一抹一样，区分大小写。如果你传了一个不存在的字符串，那么会抛出异常。

1. Weekday.values()方法。

   这个方法会返回包括所有枚举变量的数组。在该例中，返回的就是包含了七个星期的Weekday[]。可以方便的用来做循环。

枚举变量的toString()方法。

该方法直接返回枚举定义枚举变量的字符串，比如MON就返回【”MON”】。

好了，你很聪明，你已经掌握了上面的知识，你想，既然能自定义一个变量，能不能自定义两个呢？

当然可以：

public enum Weekday {
MON(1,”mon”),TUS(2,”tus”),WED(3,”wed”),THU(4,”thu”),FRI(5,”fri”),SAT(6,”sat”),SUN(0,”sun”);

private int value;
private String label;

private Weekday(int value,String label){
    this.value = value;
    this.label = label;
}

你可以定义任何你想要的变量。学完了这些，大概枚举类你也应该掌握了，但是，还有没有其他用法呢?

---

 

1. **package** com.think.enumeration;  
2.   
3. **public** **enum** Season {  
4. ​    //Java要求必须先定义枚举实例，  
5. ​    SPRING(10,20),  
6. ​    SUMMER(20,32),  
7. ​    FULL(10,20),  
8. ​    //这就是哈尔滨的真实写照  
9. ​    WINTER(-40,-5);//注意这个分号，比不可少  
10. ​      
11. ​    **private**  **double** lowTemp;  
12. ​    **private**  **double** highTemp;  
13. ​    //一旦enum定义结束，编译器就不允许我们再使用  
14. ​    //其构造器来创建任何实例了，所以即使不是private也没关系  
15. ​    **private** Season(**double** low,**double** high) {  
16. ​        lowTemp = low;  
17. ​        highTemp = high;  
18. ​    }  
19. ​      
20. ​    //自定义的方法，就像在普通的类中一样  
21. ​    **public** **void** setLow(**double** low) {  
22. ​        **this**.lowTemp = low;  
23. ​    }  
24. ​      
25. ​    //还可以覆盖父类中的方法  
26. ​    @Override  
27. ​    **public** String toString() {  
28. ​        **return** "(" + lowTemp + "," + highTemp + ")";  
29. ​    }  
30. ​      
31. ​    //甚至还可以有main方法  
32. ​    **public** **static** **void** main(String[] args) {  
33. ​        **for**(Season e : Season.values()) {  
34. ​            **if**(e == SPRING)  
35. ​                e.setLow(-10);  
36. ​            System.out.println(e);  
37. ​        }  
38. ​    }  
39. }

我们一定要抓住enum的本质：

它是一组常量的集合

。所以很多限制都是为了确保“常量性”，比如在定义枚举类时，必须先定义enum，它的构造方法在定义enum实例结束后就不能使用。出了围绕常量性的限制之外，其他的语法与普通类无异，我们可以添加普通方法，可以覆盖父类方法等。在所有的特性中，最具特色的要数在enum中除了给enum类型添加方法之外，每个实例还可以有自己的方法，这样的方法叫做常量相关方法：对于同一个方法，不同的实例可以实现自己的行为。这样甚至有了多态性。实现常量相关的方法时，可以将一个方法实现成抽象方法，每个实例提供具体实现；也可以把方法实现成普通方法，每个实例根据需求，选择是否覆盖该方法，示例如下：

---