java18-枚举类和注解

枚举类

枚举类的理解

• 类的对象是有限个的，确定的
• 当需要定义一组常量时，强烈建议枚举类

public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}
class Season{
    // 声明season对象属性 private final 修饰
    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 String getSeasonName() {
        return seasonName;
    }
    
    public String getSeasonDesc() {
        return seasonDesc;
    }
    // 提供toString

    @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

• jdk5.0新增定义方式

public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        // 继承于Enum类
        System.out.println(summer);
    }
}

enum Season1{

    //1.提供当前枚举类的多个对象,多个对象之间用逗号隔开
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎");
    // 声明season对象属性 private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 私有化类的构造器
    private Season1(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
28
29
30
31
32

Enum类常用方法

public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 summer = Season1.SUMMER;
        // 继承于Enum类
        System.out.println(summer);
        System.out.println(summer.toString());
        Season1[] values = Season1.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);

        }
        Season1 summer1 = Season1.valueOf("SUMMER");
        System.out.println(summer1);
    }
}

enum Season1{

    //1.提供当前枚举类的多个对象,多个对象之间用逗号隔开
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎");
    // 声明season对象属性 private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 私有化类的构造器
    private Season1(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
28
29
30
31
32
33
34
35
36
37
38
39
40

使用enum关键字定义枚举类实现接口的情况

• 实现接口，在enum中实现抽象方法

public class SeasonTest2 {
    public static void main(String[] args) {
        Season2 spring = Season2.valueOf("SPRING");
        spring.show();
        // 展示一段话
    }
}
interface info{
    void show();
}
enum Season2 implements info{

    //1.提供当前枚举类的多个对象,多个对象之间用逗号隔开
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎");
    // 声明season对象属性 private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 私有化类的构造器
    private Season2(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }

    // 获取属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public void show() {
        System.out.println("展示一段话");
    }
}
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

• 每个成员接口显示不一样的

public class SeasonTest2 {
    public static void main(String[] args) {
        Season2 spring = Season2.valueOf("SPRING");
        spring.show();
        // 春天展示
    }
}
interface info{
    void show();
}
enum Season2 implements info{

    //1.提供当前枚举类的多个对象,多个对象之间用逗号隔开
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天展示");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("夏天展示");
        }
    };
    // 声明season对象属性 private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 私有化类的构造器
    private Season2(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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

注解(Annotation)

• Annotation是代码中的特殊标记
• 在编译，类加载，运行时被读取，并执行对应的操作
• Annontation可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量声明

生成文档相关的注解

注：

• @param，@return，@exception这三个方法只用于方法
• @param格式要求 @param 形参名，形参类型，形参说明
• @return格式要求 @return 返回值类型 返回值说明
• @exception格式要求 @exception 异常类型，异常说明

编译时进行格式检查（JDK内置三个基本注解）

跟踪代码依赖性，实现替代文件配置功能

• Servlet3.0提供了注解，使得不再需要在web.xml文件中进行Servlet的部署
• Spring中事务管理

自定义注解

• 注解声明为@interface
• Annotation的成员变量在定义中以无参数方式方法的形式来声明，其方法名和返回值定义了该成员的名字和类型
• 如何自定义成员没有值，起到标识作用

public @interface MyAnnotation {
    String value() default "hello";
}

1
2
3
4

JDK中的元注解

可重复注解

• 可以在一个类上多次注解
• 在MyAnnotation上声明@Repeatable，成员之为MyAnnotations.class
• MyAnnotation的Target和Retention等元注解和MyAnnotations相同