止束的学习笔记

# 第三章 枚举和注解

# 3.1 枚举

# 3.1.1 引入枚举类

需求：要创建一个季节 Season 对象，季节的值是有限的几个值【即只有 spring、summer、autumn、winter】，并且是只读不需要修改

如果不用枚举：

class Season {
    private String name;
    private String desc; //描述
    
    public Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    
    public String getName() {
        return name;
    }
    public void setNmae(String name) {
        this.name = name;
    }
    
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
}

public class Enumeration {
    public static void main(String[] args) {
        Season spring = new Season("春天", "温暖");
        Season summer = new Season("夏天", "炎热");
        Season autumn = new Season("秋天", "凉爽");
        Season winter = new Season("冬天", "寒冷");
        //因为只想要一个季节类，并且季节是固定的，只有春夏秋冬，但是如果这样写的话其它人可以随意加其它的东西
        Season hongtian = new 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
33
34

# 3.1.2 枚举基本理解

  1. 枚举：enumeration，简写 enum
  2. 枚举是一组常量的集合
  3. 可以理解为：枚举属于一种特殊的类，里面只包含一组有限的特定的对象

# 3.1.3 枚举的实现方式

方式一：自定义类实现枚举

方式二：使用 enum 关键字实现枚举

# 3.1.4 自定义类实现枚举

  1. 不需要提供 setXxx() 方法，因为枚举对象值通常为只读
  2. 对枚举对象/属性使用 final + static 共同修饰，实现底层优化
  3. 枚举对象名通常使用全部大写，是常量的命名规范
  4. 枚举对象根据需要也可以有多个属性
//自定义枚举实现步骤：
//1.将构造器私有化，目的是防止直接被 new 出来
//2.将 set 有关的方法去掉，防止属性被修改
//3.在 Season 内部，直接创建固定的对象
//4.优化：可以加 final 修饰符进行优化
class Season {
    private String name;
    private String desc; //描述

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

    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 getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

public class Enum {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }

}
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

总结：

  1. 构造器私有化
  2. 在本类内部创建一组对象
  3. 对外暴露对象
  4. 可以提供 get 方法，不能提供 set 方法

# 3.1.5 enum 关键字实现枚举

/**
 * 使用 enum 关键字实现枚举
 * 1. 使用关键字 enum 代替 class
 * 2. 把 public static final Season SPRING = new Season("春天", "温暖"); 替换为 SPRING("春天", "温暖"),
 * 3. 如果有多个常量【对象】，使用 , 号间隔
 * 4. 如果使用 enum 来实现枚举，要求将定义的常量对象写在前面
 */
enum Season {
    SPRING("春天", "温暖"),
    SUMMER("夏天", "炎热"),
    AUTUMN("秋天", "凉爽"),
    WINTER("冬天", "寒冷");

    private String name;
    private String desc; //描述

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

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

public class Enum {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }

}
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

# 3.1.6 enum 常用方法

当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类，而且是一个 final 类，所以可以用 Enum 类的方法

  1. toString：Enum 类已经重写过，返回的是当前对象名，子类可以重写该方法，用于返回对象的属性信息
  2. name：放回当前对象名【常量名】，子类中不能重写
  3. ordinal：返回当前对象的位置号，默认从 0 开始
  4. values：返回当前枚举类中所有的常量
  5. valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
  6. compareTo：比较两个枚举常量，比较的就是位置号

# 3.2 注解

# 3.2.1 注解的基本介绍

（1）注解（Annotation）也被称为元数据（Metadata），用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息

（2）和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充的信息

（3）在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等，在 JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 JavaEE 旧版中所遗留的繁冗代码和 XML 配置等。

# 3.2.2 注解的使用

使用 Annotation 时要在其前面增加 @ 符号，并把该 Annotation 当成一个修饰符使用，用于修饰它支持的程序元素

三个基本的 Annotation：

（1）@Override：限定某个方法，是重写父类的方法，该注解只能用于方法

（2）@Deprecated：用于表示某个程序元素（类，方法等）已经过时

（3）@SuppressWarnings：抑制编译器警告

（4）@interface 的说明：@interface 不是 interface ，是注解类

# 3.2.2.1 @Override 使用说明

（1）@Override 表示指定重写父类的方法（从编译层面验证），如果父类没有 fly 方法，则会报错

（2）如果不写 @Override 注解，而父类仍有 public void fly(){} ，仍然可以构成重写

（3）@Override 只能修饰方法，不能修饰其它类、包、属性等

（4）查看 @Override 注解源码为 @Target(ElementType.METHOD)，说明只能修饰方法

（5）@Target 是修饰注解的注解，称为元注解

# 3.2.2.2 @Deprecated 使用说明

（1）用于表示某个程序元素（类、方法等）已经过时

（2）可以修饰方法、类、字段、包、参数等

（3）@Target(value={CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE})

（4）@Deprecated 的作用可以做到新旧版本的兼容和过渡

# 3.2.2.3 @SuppressWarnings 使用说明

（1）unchecked 是忽略没有检查的警告

（2）rawtypes 是忽略没有指定泛型的警告（传参时没有指定泛型的警告错误）

（3）unused 是忽略没有使用某个变量的警告错误

（4）@SuppressWarnings 可以修饰的程序元素为，可以查看 @Target

（5）生成 @SuppressWarnings 时，直接点击左侧的黄色提示就可以选择（注意可以指定生成的位置）

# 3.2.3 JDK 的元注解 Annotation

# 3.2.3.1 元注解的基本介绍

JDK 的元 Annotation 用于修饰其它 Annotation

# 3.2.3.2 元注解的种类

（1）Retention 指定注解的作用范围，有三种：SOURCE，CLASS，RUNTIME

（2）Target 指定注解可以在哪些地方使用

（3）Documented 指定该注解是否会在 JavaDoc 体现

（4）Inherited 子类会继承父类注解

# 3.2.3.3 @Retention 注解

@Retention 只能用于修饰一个 Annotation 定义，用于指定该 Annotation 可以保留多长时间，@Retention 包含一个 RetentionPolicy 类型的成员变量，使用 @Retention 时必须为该 value 成员变量指定值：

@Retention 的三种值

（1）RetentionPolicy.SOURCE：编译器使用后，直接丢弃这种策略的注解

（2）RetentionPolicy.CLASS：编译器将把注解记录在 class 文件中，当运行 Java 程序时，JVM 不会保留注解，这是默认值

（3）RetentionPolicy.RUNTIME：编译器将把注解记录在 class 文件中，当运行 Java 程序时，JVM 会保留注解，程序可以通过反射获取该注解

最近更新: 3/24/2025, 2:07:09 PM
第三章 枚举和注解
开发笔记   |