08_面向对象高级_枚举

枚举

1. 认识枚举

枚举是一种特殊的类。

public class Test {
    public static void main(String[] args) {
        A objX = A.X;
        System.out.println(objX);  // X
    }
}

enum A {
    // 注意，枚举类的第一行必须罗列枚举对象的名称
    X,Y,Z;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 枚举的特点

• 枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象。
• 枚举类的构造器都是私有的（写不写都只能是私有的），因此枚举类对外不能创建对象。
• 枚举都是最终类，不可以被继承。
• 枚举类中，从第二行开始可以定义类的其他各种成员。
• 编译器为枚举类新增了几个方法，并且枚举类都是继承 java.lang.Enum 类的，从 enum 类也会继承到一些方法。

public class Test {
    public static void main(String[] args) {
        // 1. 枚举类的构造器是私有的，它不能对外创建对象
//      A obj = new A();  // 报错

        // 2. 枚举类的第一行都是常量(所以可以直接通过"类名.常量名"直接获取)，记住的是枚举类的对象
        A objX = A.X;
        A objY = A.Y;

        // 3. 枚举类为我们提供了一些API
        A[] all = A.values();  // 获取所有的枚举对象
        A objZ = A.valueOf("Z");  // 根据枚举的常量名来获得对应的枚举对象
        System.out.println(objZ.name());  // 输出枚举对象的名称：Z
        System.out.println(objZ.ordinal());  // 输出枚举对象的索引：2

    }
}

enum A {
    X, Y, Z;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3. 抽象枚举（扩展）

public class Test {
    public static void main(String[] args) {
        A obj = A.Y;
        obj.run();  // Jack跑步中...

    }
}

enum A {
    // 创建对象X、Y的时候，因为run方法是抽象的，所有对象X、Y无法初始化自己的run方法
    // 因此，我们要调用构造器重写run方法
    X() {
        @Override
        public void run() {

        }
    },
    Y("Jack") {
        @Override
        public void run() {
            System.out.println(getName() + "跑步中...");
        }
    };

    // 抽象的————对象的方法
    public abstract void run();

    private String name;

    // 无参构造器
    A() {
    }

    // 有参构造器
    A(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
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

4. 枚举实现单例

public class Test {
    public static void main(String[] args) {
        // 通过枚举快速实现单例
        H obj1 = H.OBJ;
        H obj2 = H.OBJ;
        System.out.println(obj1 == obj2);  // true
    }
}

enum H {
    OBJ;
}
1
2
3
4
5
6
7
8
9
10
11
12

5. 枚举常见的应用场景

• 用来表示一组信息，然后作为参数进行传输

  （选择定义一个个的常量来表示一组信息，并作为参数传输）

• 参数值不受约束

  （选择定义枚举表示一组信息，并作为参数传输）

• 代码可读性好，参数值得到了约束，对使用者更友好，建议使用！

案例展示：

public class Test {
    // main方法
    public static void main(String[] args) {
        check(0);  // 检测到为女性用户，将为您推荐xxx
    }

    // check方法
    public static void check(int gender) {
        switch (gender) {
            case Constant.female:
                System.out.println("检测到为女性用户，将为您推荐xxx");
                break;
            case Constant.male:
                System.out.println("检测到为男性用户，将为您推荐yyy");
                break;
        }
    }
}

class Constant {
    // 常量
    public static final int female = 0;
    public static final int male = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

参照上面的案例，用枚举的方法进行改写，代码如下：

public class Test {
    // main方法
    public static void main(String[] args) {
        check(Constant.male);  // 使用枚举，能够让对方不能乱传参数进来
    }

    // check方法
    public static void check(Constant gender) {
        switch (gender) {
            case male:
                System.out.println("检测到为女性用户，将为您推荐xxx");
                break;
            case female:
                System.out.println("检测到为男性用户，将为您推荐yyy");
                break;
        }
    }
}

enum Constant {
    male, female;
}

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