枚举
# 枚举
可以一枚一枚的列举出来。前提:个数有限且值确定。
在
java
中,类的对象是有限个,确定的,这个类我们可以定义为一个枚举类。
举例:
星期:一二三四五六日
性别:男女
季节:春夏秋冬
自定义枚举类(JDK1.5 之前)
public class Season {
// 属性
private final String seasonName;
private final String seasonDesc;
// 私有的构造方法
private Season(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
// 提供枚举类的有限的,确定的对象
public static final Season SPRING = new Season("春天", "春暖花开");
public static final Season SUMMER = new Season("夏天", "烈日炎炎");
public static final Season AUTUMN = new Season("秋天", "秋高气爽");
public static final Season WINTER = new Season("冬天", "冰天雪地");
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
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
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
测试类
public class TestSeason {
public static void main(String[] args) {
Season spring = Season.SPRING;
System.out.println(spring);
System.out.println(spring.getSeasonDesc());
}
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
# JDK1.5 之后使用关键字Enum
关键字
注意
enum 枚举类,要求对象、常量必须放在最开始的位置上
package com.wxvirus.enums;
public enum EnumSeason {
// enum 枚举类,要求对象、常量必须放在最开始的位置上
SPRING("春天", "春暖花开"),
SUMMER("春天", "春暖花开"),
AUTUMN("春天", "春暖花开"),
WINTER("春天", "春暖花开");
private final String seasonName;
private final String seasonDesc;
private EnumSeason(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
}
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
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
多个对象对象之间用逗号进行连接,最后一个对象后面用分号结束。
public class TestSeason {
public static void main(String[] args) {
// 我们自定义的枚举类的上层父类是 Object
Season spring = Season.SPRING;
System.out.println(spring);
System.out.println(spring.getSeasonDesc());
EnumSeason winter = EnumSeason.WINTER;
System.out.println(winter);
// enum 关键字对应的枚举类的上层父类是 java.lang.Enum
System.out.println(EnumSeason.class.getSuperclass().getName());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
在源码中经常看到别人定义的枚举类形态:
public enum EnumSeason {
SPRING,
SUMMER,
AUTUMN,
WINTER;
}
1
2
3
4
5
6
7
2
3
4
5
6
7
为什么这么简单?因为这个枚举类底层没有属性,没有构造器,toString
、set/get方法
都删掉不写了,按理来说应该写为:SPRING()
现在连括号也可以省略,就变成SPRING
,看到的形态就剩常量名了。
# Enum 类的常用方法
public class TestSeason {
public static void main(String[] args) {
// toString()
EnumSeason autumn = EnumSeason.AUTUMN;
System.out.println(autumn.toString()); // 获取对象的名字
// values: 返回枚举类对象的数组
EnumSeason[] values = EnumSeason.values();
for (EnumSeason value : values) {
System.out.println(value);
}
// valueOf: 通过对象名获取这个枚举对象,否则抛出异常
EnumSeason autumn1 = EnumSeason.valueOf("AUTUMN"); // 对象名必须传对
System.out.println(autumn1);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Enum 类实现接口
定义一个接口
public interface TestInterface {
void show();
}
1
2
3
4
2
3
4
枚举类实现接口,并且重写show
方法
public enum Season implements TestInterface {
SPRING,
SUMMER,
AUTUMN,
WINTER;
@Override
public void show() {
System.out.println("This is Season...");
}
}
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
测试类:
public class Test {
public static void main(String[] args) {
Season autumn = Season.AUTUMN;
autumn.show();
Season summer = Season.SUMMER;
summer.show();
}
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
上面发现:所有的枚举对象,调用这个
show()
方法的时候走的都是同一个方法,结果都一样。This is Season... This is Season...
1
2但是,我们现在想要:不同的对象,调用的
show()
方法也不同:
public enum Season implements TestInterface {
SPRING {
@Override
public void show() {
System.out.println("This is Spring...");
}
},
SUMMER {
@Override
public void show() {
System.out.println("This is Summer...");
}
},
AUTUMN {
@Override
public void show() {
System.out.println("This is Autumn...");
}
},
WINTER {
@Override
public void show() {
System.out.println("This is Winter...");
}
};
// @Override
// public void show() {
// System.out.println("This is Season...");
// }
}
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
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
上面的测试类再一次的结果:
This is Autumn...
This is Summer...
1
2
2
# 实际应用
public class Person {
private int age;
private String name;
private Gender sex;
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
", sex=" + sex +
'}';
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Gender getSex() {
return sex;
}
public void setSex(Gender sex) {
this.sex = sex;
}
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
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
public enum Gender {
男,
女
}
1
2
3
4
2
3
4
public class Test {
public static void main(String[] args) {
Person p = new Person();
p.setAge(19);
p.setName("wujie");
p.setSex(Gender.男); // 传入枚举类的对象,在入口处对参数进行限制
System.out.println(p);
}
}
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
switch
后面的括号中可以传入枚举类型
public class Test {
public static void main(String[] args) {
Gender sex = Gender.男;
switch (sex) {
case 女:
System.out.println("是个女孩");
break;
case 男:
System.out.println("是个男孩");
break;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
编辑 (opens new window)
上次更新: 2021/11/27, 16:44:03