java 枚举——java中枚举的运用和使用场景

转自：http://blog.csdn.net/yehui928186846/article/details/51426415

基本特性：

1，enum关键字 

枚举enum是同class，interface同一级别的特性。 

我们可以把enum看作一个抽象类，但是它又有它的不同之处，enum不能被继承。

这一点其实在Android源码中就得到了证实：

Public abstract class Enum<E extends Enum<E>> implements Serializable,Comparable <E>
{
...
}

1
2
3
4
1
2
3
4

从源码中可以看出Enum相当于一个抽象类。所以，enum可以看成一个抽象类并且和class、interface同级。

2，枚举的定义 

如何在Enum中定义枚举常量呢？ 

1，枚举常量没有任何修饰符 

2，每个常量以“，”分隔，以“；”结束枚举常量的描述。 

3，枚举常量必须定义在所有方法或者构造器之前。

规矩我们已经知道了，接下来就看看如何在代码里定义枚举常量了：

//枚举常量的定义可以在最后一个元素加，再加；结束。常量区分大小写
public enum OrdinaryEnums {
red,
RED,
green,
yellow,
blue,;
}

1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

3，使用枚举的目的 

当我们需要限制一系列变量的时候，通常想到数组或者集合；其实很多时候我们需要限定变量需要做的事情很多，或者说如果被限制的变量可以做其他事情的话就更好了，而不是单纯的一个变量（String，int，double）。

那么，枚举的作用不仅仅可以让你使用限制在一个enum中的变量，并且这些变量的灵活性和拓展性很好。 

举例说明： 

如果我们需要使用一些状态，比如一个星期的状态。 

我们可以用数组：

String[] week=new String[7];
week[0]="星期天";
week[1]="星期一";
week[2]="星期二";
week[3]="星期三";
week[4]="星期四";
week[5]="星期五";
week[6]="星期六";
String weekday=week[0];

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

或者集合，这些表示大家都很熟悉。 

那么看看用枚举如何来写：

public enum WeekEnums {
//注：枚举写在最前面，否则编译出错
Sunday,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,;

private static String getWeek(WeekEnums weekEnums) {
String week = null;
switch (weekEnums) {
case Sunday://星期天
week = "星期天";
break;
case Monday://星期一
week = "星期一";
break;
case Tuesday:// 星期二
week = "星期二";
break;
case Wednesday://星期三
week = "星期三";
break;
case Thursday:// 星期四
week = "星期四";
break;
case Friday://星期五
week = "星期五";
break;
case Saturday://  星期六
week = "星期六";
break;
}
return week;
}
}
//获取方式：
String weekday = WeekEnums.getWeek(WeekEnums.Friday);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

可能，有人会说，这样写可是很麻烦。的确比数组或者集合麻烦了，但是它的拓展性是非常好的，因为往往我们需要的不仅仅是一个字符串，不仅仅是调用数字得到一个以供显示的星期，而是更多的逻辑处理。

我们来重写一下枚举中getWeek方法：

private static String getWeek(WeekEnums weekEnums) {
String week = null;
String behavior = null;
switch (weekEnums) {
case Sunday://星期天
week = "星期天";
behavior = "星期天我要去打球";//模仿一个逻辑处理
break;
case Monday://星期一
week = "星期一";
behavior = "我要去上课";//模仿一个逻辑处理
break;
case Tuesday:// 星期二
week = "星期二";
behavior = "我要去奶奶家";//模仿一个逻辑处理
break;
case Wednesday://星期三
week = "星期三";
behavior = "我要去做义工";//模仿一个逻辑处理
break;
case Thursday:// 星期四
week = "星期四";
behavior = "我要去做义工";//模仿一个逻辑处理
break;
case Friday://星期五
week = "星期五";
behavior = "我要去做义工";//模仿一个逻辑处理
break;
case Saturday://  星期六
behavior = "我要去做义工";//模仿一个逻辑处理
week = "星期六";
break;
}
return week;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

这时候，枚举的有点久体现出来了，不仅仅可以获得状态，还可以在枚举中处理逻辑。 

这是数组或者集合无法做到了，而且枚举完成的逻辑不仅仅这些，还能完成更多更复杂的逻辑处理。

4，使用枚举

/**
* 普通的枚举
* 普通枚举在作用在于控制变量的范围，作用和数组、集合一样
*/
public class OrdinaryEnum {
public enum OrdinaryEnums {
red,
green,
yellow,
blue,;
}

private void test(OrdinaryEnums ordinaryEnums) {
switch (ordinaryEnums) {
case red://表示红色的枚举
break;
case green://表示绿色的枚举
break;
case yellow://表示黄色的枚举
break;
case blue://表示蓝色的枚举
break;
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

**
* 带属性的枚举
* 通过枚举可以获得一个相应的结果
*/
public class AattributeEnum {

public enum AattributeEnums {
//注：枚举写在最前面，否则编译出错
red,
RED,
green,
yellow,
blue,;
private static int color = Color.WHITE;

private static int getColor(AattributeEnums aattributeEnums) {
switch (aattributeEnums) {
case red://表示红色的枚举
color = Color.RED;
break;
case green://表示绿色的枚举
color = Color.GREEN;
break;
case yellow://表示黄色的枚举
color = Color.YELLOW;
break;
case blue://表示蓝色的枚举
color = Color.BLUE;
break;
case RED://表示蓝色的枚举
color = Color.RED;
break;
}
return color;
}
}

private void test() {
int color = AattributeEnums.getColor(AattributeEnums.red);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

/**
* 带构造器的枚举
* 枚举的构造器类似于类的构造方法
* 不同的是，枚举的构造器只提供给内部的枚举变量使用
* 外界调用具体的枚举变量就相当于执行了构造器中的逻辑
*/
public class ConstructorEnum {

public enum ConstructorEnums {
red(Color.RED),
green(Color.RED),
yellow(Color.RED),
blue(Color.BLUE),;
private int color;

ConstructorEnums(int color) {
this.color = color;
}

private int getColor() {
return color;
}
}

private void test() {
int color = ConstructorEnums.red.getColor();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
* 带抽象方法的枚举
* 在枚举中定义抽象方法，那么这个抽象方法所有的枚举变量都要去实现；不管有多少个抽象方法都一样
* 外界调用相对应的枚举变量中的抽象方法就可以让枚举处理自己实现的这个抽象方法的具体实现逻辑
*/
public class AbstractEnum {

public enum AbstractEnums {
red {
public int getColor() {
return Color.RED;
}

public String getWeek() {
return "星期一";
}
},
green {
public int getColor() {
return Color.GREEN;
}

public String getWeek() {
return "星期一";
}
},
yellow {
public int getColor() {
return Color.YELLOW;
}

public String getWeek() {
return "星期一";
}
},
blue {
public int getColor() {
return Color.BLUE;
}

public String getWeek() {
return "星期一";
}
},;

public abstract int getColor();

public abstract String getWeek();
}

private void test() {
int color = AbstractEnums.red.getColor();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

我们可以通过这四种方式根据不同的情景来使用相应的枚举处理一些复杂的逻辑。

总结： 

当我们在需要控制一个方法传入的参数的时候，并且这些参数可以自己处理一些事情的时候我们就可以选择枚举来实现。

例如：时间选择格式，我们可以用枚举来规定格式，然后外界只能调用枚举中的格式，然后枚举再去将规定的格式传给时间用于格式化。 

所有的逻辑处理交给枚举来完成，我们只需要调用相应的枚举类型就能得到想要的时间格式的时间。 

还有很多地方都体现出枚举的好处，例如：网络请求的接口定义；一些辑返回参数的定义；

只要是需要控制变量的数量或者范围，并且拿到变量后还需要处理一些逻辑的场景都可以用枚举来完成