第10章枚举类与注解

发表于 2021-12-25 分类于程序设计， Java 阅读次数：本文字数： 11k 阅读时长 ≈ 10 分钟

第10章、枚举类与注解

一、枚举类的使用

（一）、如何自定义枚举类

枚举类的理解
- 类的对象只有有限个，确定的。举例如下：星期类、性别类、季节类、支付方式（现金、微信、支付宝）
- 当需要定义一组常量时，强烈建议使用枚举类
- 如果枚举类中只有一个对象，可以看成单例模式的实现方式

如何定义枚举类

JDK5.0前，自定义枚举类

// 要有有限个、确定的对象 ==> 私有化类的构造器
public class SeasonTest {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        System.out.println(season);
    }
}

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
    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 + '\'' +
                '}';
    }
}

私有化构造器
私有化属性，且属性声明为final
类的内部创建固定数量的当前类的对象
提供属性的get方法
重写toString方法

（二）、如何使用关键字enum定义枚举类（重点）

JDK5.0后，可使用enum关键字定义枚举类

定义的枚举类继承于 java.lang.Enum类

public class SeasonTest {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        System.out.println(season); // SPRING
        System.out.println(season.getClass().getSuperclass()); 
        //class java.lang.Enum
    }
}

// 使用enum关键字
enum Season{

    // 1. 提供当前枚举类的对象，多个对象之间用逗号隔开，末尾对象用分号结束
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "夏日炎炎"),
    AUTUMN("秋天", "秋高气爽"),
    WINTER("冬天", "冰天雪地");

    // 声明对象属性
    private final String seasonName;
    private final String seasonDesc;

    // 私有化类的构造器，并给对象属性赋值
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    // toString()方法无需重写，输出为对象名
//    @Override
//    public String toString() {
//        return "Season{" +
//                "seasonName='" + seasonName + '\'' +
//                ", seasonDesc='" + seasonDesc + '\'' +
//                '}';
//    }
}

（三）、Enum类的主要方法（重点）

values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
toString()：返回当前枚举类对象常量的名称

（四）、实现接口的枚举类

和普通 Java 类一样，枚举类可以实现一个或多个接口
情况一：实现接口，在类中实现方法；
即若每个枚举值在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。

情况二：

若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法

通过实现接口，并在枚举类的每个对象后分别实现接口中的方法
每个枚举成员调用show方法时会按各自实现方法中定义的操作进行操作

public class SeasonTest {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        System.out.println(season);
        System.out.println(season.getClass().getSuperclass());
        season.show();
    }
}

interface info{
    void show();
}
// 使用enum关键字
enum Season implements info{

    // 1. 提供当前枚举类的对象，多个对象之间用逗号隔开，末尾对象用分号结束
    SPRING("春天", "春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里");
        }
    },
    SUMMER("夏天", "夏日炎炎"){
        @Override
        public void show() {
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天", "秋高气爽"){
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天", "冰天雪地"){
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };

    // 声明对象属性
    private final String seasonName;
    private final String seasonDesc;

    // 私有化类的构造器，并给对象属性赋值
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    // toString()方法无需重写，输出为对象名
//    @Override
//    public String toString() {
//        return "Season{" +
//                "seasonName='" + seasonName + '\'' +
//                ", seasonDesc='" + seasonDesc + '\'' +
//                '}';
//    }
}

二、注解的使用

（一）、注解（Annotation）概述

从JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)
Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在Annotation的 “name=value” 对中。
在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式。

（二）、常见的Annotation示例

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

示例一：生成文档相关的注解
- @author 标明开发该类模块的作者，多个作者之间使用,分割
- @version 标明该类模块的版本
- @see 参考转向，也就是相关主题
- @since 从哪个版本开始增加的
- @param 对方法中某参数的说明，如果没有参数就不能写
- @return 对方法返回值的说明，如果方法的返回值类型是void就不能写
- @exception 对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写其中
@param @return 和@exception 这三个标记都是只用于方法的。 @param的格式要求：@param 形参名形参类型形参说明 @return 的格式要求：@return 返回值类型返回值说明 @exception的格式要求：@exception 异常类型异常说明 @param和@exception可以并列多个

示例二：在编译时进行格式检查(JDK内置的三个基本注解)

@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择

@SuppressWarnings: 抑制编译器警告

public static void main(){
	@SuppressWarnings("unused")
    int num = 10;
    // 抑制未使用警告
    
    @SuppressWarnings({ "unused", "rawtypes" })
    ArrayList list = new ArrayList();
    // 抑制未使用变量 未使用泛型
    
}

示例三：跟踪代码依赖性，实现替代配置文件功能
- Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署
- spring框架中关于“事务”的管理

（三）、自定义Annotation

如何自定义注解
- 参照SuppressWarnings的定义
- 注解声明为 @interface
- 内部定义成员，通常使用value表示
- 可指定成员的默认值，使用default定义
- 如果自定义注解无成员，表明是一个标识作用。称为标记
- 如果注解有成员，在使用注解时，需要指明成员的值
- 自定义注解必须配上注解的信息处理流程（使用反射）才有意义

自定义注解通常都会指明两个元注解：Retention、Target

自定义注解自动继承了java.lang.annotation.Annotation接口
Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组。
可以在定义 Annotation 的成员变量时为其指定初始值, 指定成员变量的初始值可使用default 关键字
如果只有一个参数成员，建议使用参数名为value
如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认值。格式是“参数名 = 参数值”，如果只有一个参数成员，且名称为value，可以省略“value=”
没有成员定义的 Annotation 称为标记; 包含成员变量的 Annotation 称为元数据Annotation
注意：自定义注解必须配上注解的信息处理流程才有意义。

public @interface MyAnnotation{
    String[] value(); // 看起来像方法，其实是成员变量
}

// 指定成员的默认值
public @interface MyAnnotation{
    String[] value() default "hello"; // 看起来像方法，其实是成员变量
}

// 使用
@MyAnnotation(value = "hi", xxx = xxxx)

（四）、JDK中的元注解

元注解：对现有的注解解释说明的注解
JDK 的元Annotation 用于修饰其他Annotation 定义
JDK5.0提供了4个标准的meta-annotation类型，分别是：
- Retention：指定所修饰的Annotation的生命周期，包含SOURCE(默认行为)。只有声明为RUNTIME生命周期的注解才能通过反射获取。
- Target：用于指定被修饰的Annotation能用于修饰那些程序元素（类、构造器、方法、...）
- Documented（出现频率低）：表示被Documented所修饰的注解若在程序元素上用到，则在被javadoc解析时保留下来该注解
- Inherited：被它修饰的Annotation具有继承性（若该Annotation修饰父类，则子类不用显式注解仍然有父类的注解信息）
元注解类比：元数据 String name = "Tom"; 其中"Tom"是最核心的，而String 和 name都是来解释说明修饰"Tom"数据的，即String 和 name可看成是"Tom"的元数据

（五）、利用反射获取注解信息

前提：
- 要求此注解的元注解Retention中声明的生命周期状态为：RUNTIME

（六）、JDK8中注解的新特性（可重复注解、类型注解）

可重复注解

在MyAnnotation上声明@repeatable()，成员值为MyAnnotations.class

MyAnnotation的@Target和@Retention等元注解和MyAnnotaions相同

// MyAnnotationTest.java
public class MyAnnotationTest {

}

//JDK 8前重复注解写法
//@MyAnnotations({@MyAnnotation(value = "Hi - 1"), @MyAnnotation(value = "Hi - 2")})
//JDK 8后重复注解写法
//  - 在MyAnnotation上声明@repeatable()，成员值为MyAnnotations.class
//  - MyAnnotation的@Target和@Retention和MyAnnotaions相同
@MyAnnotation(value = "Hi - 1")
@MyAnnotation(value = "Hi - 2")
class AnnotationTest{

}


// MyAnnotation.java
@Retention(RUNTIME)
@Repeatable(MyAnnotations.class)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR})
public @interface MyAnnotation {
    String value() default "hi";
}


// MyAnnotations.java
@Retention(RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR})
public @interface MyAnnotations {
    MyAnnotation[] value();
}

类型注解

ElementType.TYPE_PARAMETER：表示该注解能写在类型变量声明语句中（如泛型声明）
ElementType.TYPE_USE：表示该注解能写在使用类型的任何语句中

// MyAnnotationTest.java
class Generic<@MyAnnotation T>{
    public void show() throws @MyAnnotation RuntimeException{
        ArrayList<@MyAnnotation String> list = new ArrayList<>();

        int num = (@MyAnnotation int) 10L;
    }
}


// MyAnnotation.java
@Retention(RUNTIME)
@Repeatable(MyAnnotations.class)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
public @interface MyAnnotation {
    String value() default "hi";
}


// MyAnnotation.java
@Retention(RUNTIME)
@Repeatable(MyAnnotations.class)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
public @interface MyAnnotation {
    String value() default "hi";
}

每日一考

什么是枚举类？枚举类的对象声明的修饰符都有哪些？
- 类的对象只有有限个，确定的。举例如下：星期类、性别类、季节类、支付方式（现金、微信、支付宝）
- 当需要定义一组常量时，强烈建议使用枚举类
- 如果枚举类中只有一个对象，可以看成单例模式的实现方式
- ```
  public static final
```
什么是元注解？说说Retention和Target元注解的作用
- 元注解是对现有的注解解释说明的注解
- Retention：指定所修饰的Annotation的生命周期，包含SOURCE(默认行为)。只有声明为RUNTIME生命周期的注解才能通过反射获取。
- Target：用于指定被修饰的Annotation能用于修饰那些程序元素（类、构造器、方法、...）

Hunt's Blog