Enum（枚举）

!!! note 目录

Enum（枚举）

一、枚举的基础用法

1.1 基本概念

  1. 枚举类型：枚举类型是一种特殊的类，用于表示一组常量。每个枚举常量实际上是该枚举类型的一个实例。
  2. 枚举常量：枚举类型的实例，用于表示枚举类型的固定值。例如，枚举类型 Day 可以有常量 MONDAY, TUESDAY 等。
  3. 类型安全：使用枚举类型比使用 int 或 String 常量更具类型安全性，因为编译器会检查类型。
1
2
3
4
5
6
7
8
9
10
package com.camellia.Enum;

/**
 * 枚举类型：季节
 */
public enum Season {
    // 直接定义枚举类型，每一个枚举值可以看做类中的常量。
    SPRING, SUMMER, AUTUMN, WINTER;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
    public void testEnum(){
        Season season = get();
        switch (season){
            case SPRING -> System.out.println("地平线·春季");
            case SUMMER -> System.out.println("地平线·夏季");
            case AUTUMN -> System.out.println("地平线·秋季");
            case WINTER -> System.out.println("地平线·冬季");
        }
    }

    public  Season get(){
        return Season.AUTUMN;
    }

1.2 反编译枚举

  1. 所有枚举类型都默认继承java.lang.Enum，因此枚举类型无法继承其他类。
  2. 所有枚举类型都被final修饰，所以枚举类型无法继承。
  3. 所有枚举值都是常量。
  4. 所有枚举类型都有一个values数组（可以通过values()获取所有枚举制值并且遍历）

1
2
3
4
5
6
7
8
/**
 * 获取所有枚举值，遍历。
 */
@Test
public void testEnumValues(){
    Season[] values = Season.values();
    for (Season value:values) System.out.println(value);
}

二、枚举的高级用法

  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
25
26
27
28
29
30
31
32
33
34
package com.camellia.Enum;

/**
 * 枚举类型：季节
 */
public enum Season {
//    接定义枚举类型，每一个枚举值可以看做类中的常量。
    SPRING, SUMMER, AUTUMN, WINTER;
    
//    静态代码块
    static {
        System.out.println("枚举类型Season的静态代码块执行了");
    }

//    构造代码块
    {
        System.out.println("Season构造代码块执行了");
    }
    
//    静态变量
    public final static int A = 10;
//    实例变量
    private final int  b= 20;
//    静态方法
    public static int getA(){
        return  A;
    }
//    实例方法
    public int getB(){
        return b;
    }        
            
}

  1. 枚举类中的构造方法是私有化的（默认就是私有化的，只能在本类调用。）
    • 枚举类的构造方法不能使用new来调用。
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
package com.camellia.Enum;

public enum SeasonPlus {
    // 定义了有参数的构造方法之后，通过以下代码来调用构造方法。
    // 注意枚举类的构造方法不能使用new来调用，并且枚举类的构造方法只能在本类中调用。
    SPRING("春季","地平线春季赛事"),
    SUMMER("夏季","地平线夏季赛事"),
    AUTUMN("秋季","地平线秋季赛事"),
    WINTER("冬季","地平线冬季赛事");

    //提供属性
    private final String name;
    private final String desc;

    SeasonPlus(String name, String desc){
        this.name=name;
        this.desc=desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.camellia.Enum;

public class SeasonPlusTest {
    public static void main(String[] args) {
        SeasonPlus seasonPlus=SeasonPlusTest.get();
        switch (seasonPlus){
            case SPRING -> System.out.println(seasonPlus.getDesc());
            case SUMMER -> System.out.println(seasonPlus.getDesc());
            case AUTUMN -> System.out.println(seasonPlus.getDesc());
            case WINTER -> System.out.println(seasonPlus.getDesc());
        }

        //遍历
        SeasonPlus[] values = SeasonPlus.values();
        for(SeasonPlus value: values) System.out.println(value.getName()+" ====> "+value.getDesc());
    }

    public static SeasonPlus get() {
        return SeasonPlus.SPRING;
    }
}

三、枚举类型继承接口

3.1 整个枚举类型实现接口

这种方法是让整个枚举类型实现接口，并为所有枚举常量提供统一的实现。

1
2
3
public interface Eatable {
    public void eat();
}
1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 枚举类型：季节
 */
public enum Season implements Eatable{
//    接定义枚举类型，每一个枚举值可以看做类中的常量。
    SPRING, SUMMER, AUTUMN, WINTER;
    
    @Override
    public void eat() {
        System.out.println("吃点水果");
    }
}

3.2 每个枚举常量分别实现接口

这种方法是让每个枚举常量分别实现接口，从而为每个枚举常量提供不同的实现。

1
2
3
public interface Eatable {
    public void eat();
}
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
public enum SeasonPlus implements Eatable{
    SPRING("春季","地平线春季赛事"){
        @Override
        public void eat() {
            System.out.println("春季吃苹果");
        }
    },
    SUMMER("夏季","地平线夏季赛事"){
        @Override
        public void eat() {
            System.out.println("夏季吃西瓜");
        }
    },
    AUTUMN("秋季","地平线秋季赛事"){
        @Override
        public void eat() {
            System.out.println("秋季吃杏桃");
        }
    },
    WINTER("冬季","地平线冬季赛事"){
        @Override
        public void eat() {
            System.out.println("冬季吃橘子");
        }
    };

    //提供属性
    private final String name;
    private final String desc;

    SeasonPlus(String name, String desc){
        this.name=name;
        this.desc=desc;
    }
}