java枚举类&注解

1. 枚举类的使用

主要内容

  • 如何自定义枚举类
  • 如何使用关键字enum定义枚举类
  • Enum类的主要方法
  • 实现接口的枚举类

枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类

当需要定义一组常量时，强烈建议使用枚举类

如果枚举类中只有一个对象，则可以作为单例模式的实现方式。

1.1. 如何定义枚举类

1.1.1. 方式一：jdk5.0之前，自定义枚举类

  1.     public class SeasonTest {
  3.         public static void main(String[] args) {
  4.             Season spring = Season.SPRING;
  5.             System.out.println(spring);
  7.         }
  9.     }
  10.     //自定义枚举类
  11.     class Season{
  12.         //1.声明Season对象的属性:private final修饰
  13.         private final String seasonName;
  14.         private final String seasonDesc;
  16.         //2.私有化类的构造器,并给对象属性赋值
  17.         private Season(String seasonName,String seasonDesc){
  18.             this.seasonName = seasonName;
  19.             this.seasonDesc = seasonDesc;
  20.         }
  22.         //3.提供当前枚举类的多个对象：public static final的
  23.         public static final Season SPRING = new Season("春天","春暖花开");
  24.         public static final Season SUMMER = new Season("夏天","夏日炎炎");
  25.         public static final Season AUTUMN = new Season("秋天","秋高气爽");
  26.         public static final Season WINTER = new Season("冬天","冰天雪地");
  28.         //4.其他诉求1：获取枚举类对象的属性
  29.         public String getSeasonName() {
  30.             return seasonName;
  31.         }
  33.         public String getSeasonDesc() {
  34.             return seasonDesc;
  35.         }
  36.         //4.其他诉求1：提供toString()
  37.         @Override
  38.         public String toString() {
  39.             return "Season{" +
  40.                     "seasonName='" + seasonName + '\'' +
  41.                     ", seasonDesc='" + seasonDesc + '\'' +
  42.                     '}';
  43.         }
  44.     }

1.1.2. 方式二：jdk5.0时，可以使用enum关键字定义枚举类

  1.     public class SeasonTest {
  3.         public static void main(String[] args) {
  4.             Season spring = Season.SPRING;
  5.             System.out.println(spring);
  7.             System.out.println(Season.class.getSuperClass());
  9.         }
  11.     }
  12.     //使用enum关键字定义枚举类
  13.     //定义的枚举类默认继承于java.lang.Enum类
  14.     enum Season{
  15.         //1提供当前枚举类的对象，多个对象之间用","分隔，末尾对象用";"结束
  16.         SPRING("春天","春暖花开")，
  17.         SUMMER("夏天","夏日炎炎")，
  18.         AUTUMN("秋天","秋高气爽")，
  19.         WINTER("冬天","冰天雪地");
  21.         //2.声明Season对象的属性：private final修饰
  22.         private final String seasonName;
  23.         private final String seasonDesc;
  25.         //2.私有化类的构造器,并给对象属性赋值
  26.         private Season(String seasonName,String seasonDesc){
  27.             this.seasonName = seasonName;
  28.             this.seasonDesc = seasonDesc;
  29.         }
  31.         //4.其他诉求1：获取枚举类对象的属性
  32.         public String getSeasonName() {
  33.             return seasonName;
  34.         }
  36.         public String getSeasonDesc() {
  37.             return seasonDesc;
  38.         }
  39.         //4.其他诉求1：提供toString()
  40. //        @Override
  41. //        public String toString() {
  42. //            return "Season{" +
  43. //                    "seasonName='" + seasonName + '\'' +
  44. //                    ", seasonDesc='" + seasonDesc + '\'' +
  45. //                    '}';
  46. //        }
  47.     }

1.2. Enum类中的常用方法

Enum类的主要方法：

  • values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的 枚举值。
  • valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常： IllegalArgumentException。
  • toString()：返回当前枚举类对象常量的名称
  1. /**
  2.  * 使用enum关键字定义枚举类
  3.  * 说明：定义的枚举类默认继承于java.lang.Enum类
  4.  *
  5.  * @author shkstart
  6.  * @create 2019 上午 10:35
  7.  */
  8. public class SeasonTest1 {
  9.     public static void main(String[] args) {
  10.         Season1 summer = Season1.SUMMER;
  11.         //toString():返回枚举类对象的名称
  12.         System.out.println(summer.toString());
  14. //        System.out.println(Season1.class.getSuperclass());
  15.         System.out.println("****************");
  16.         //values():返回所有的枚举类对象构成的数组
  17.         Season1[] values = Season1.values();
  18.         for(int i = 0;i < values.length;i++){
  19.             System.out.println(values[i]);
  20.         }
  21.         System.out.println("****************");
  22.         Thread.State[] values1 = Thread.State.values();
  23.         for (int i = 0; i < values1.length; i++) {
  24.             System.out.println(values1[i]);
  25.         }
  27.         //valueOf(String objName):返回枚举类中对象名是objName的对象。
  28.         Season1 winter = Season1.valueOf("WINTER");
  29.         //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
  30. //        Season1 winter = Season1.valueOf("WINTER1");
  31.         System.out.println(winter);
  32.     }
  33. }
  35. //使用enum关键字定义枚举类
  36.     //定义的枚举类默认继承于java.lang.Enum类
  37.     enum Season{
  38.         //1提供当前枚举类的对象，多个对象之间用","分隔，末尾对象用";"结束
  39.         SPRING("春天","春暖花开")，
  40.         SUMMER("夏天","夏日炎炎")，
  41.         AUTUMN("秋天","秋高气爽")，
  42.         WINTER("冬天","冰天雪地");
  44.         //2.声明Season对象的属性：private final修饰
  45.         private final String seasonName;
  46.         private final String seasonDesc;
  48.         //2.私有化类的构造器,并给对象属性赋值
  49.         private Season(String seasonName,String seasonDesc){
  50.             this.seasonName = seasonName;
  51.             this.seasonDesc = seasonDesc;
  52.         }
  54.         //4.其他诉求1：获取枚举类对象的属性
  55.         public String getSeasonName() {
  56.             return seasonName;
  57.         }
  59.         public String getSeasonDesc() {
  60.             return seasonDesc;
  61.         }
  62.         //4.其他诉求1：提供toString()
  63. //        @Override
  64. //        public String toString() {
  65. //            return "Season{" +
  66. //                    "seasonName='" + seasonName + '\'' +
  67. //                    ", seasonDesc='" + seasonDesc + '\'' +
  68. //                    '}';
  69. //        }
  70.     }

1.3. 实现接口的枚举类

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

  • 情况一：实现接口，在enum类中实现抽象方法 ```java public class SeasonTest1 { public static void main(String[] args) {
    1.   Season1 summer = Season1.SUMMER;
    2.   //toString():返回枚举类对象的名称
    3.   System.out.println(summer.toString());

// System.out.println(Season1.class.getSuperclass()); System.out.println(“**“); //values():返回所有的枚举类对象构成的数组 Season1[] values = Season1.values(); for(int i = 0;i < values.length;i++){ System.out.println(values[i]); values[i].show(); } System.out.println(“**“); Thread.State[] values1 = Thread.State.values(); for (int i = 0; i < values1.length; i++) { System.out.println(values1[i]); }

  1.     //valueOf(String objName):返回枚举类中对象名是objName的对象。
  2.     Season1 winter = Season1.valueOf("WINTER");
  3.     //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException

// Season1 winter = Season1.valueOf(“WINTER1”); System.out.println(winter); winter.show(); } }

interface Info { void show(); }

//使用enum关键字定义枚举类 //定义的枚举类默认继承于java.lang.Enum类 enum Season implements Info{ //1提供当前枚举类的对象，多个对象之间用”,”分隔，末尾对象用”;”结束 SPRING(“春天”,”春暖花开”)， SUMMER(“夏天”,”夏日炎炎”)， AUTUMN(“秋天”,”秋高气爽”)， WINTER(“冬天”,”冰天雪地”);

  1.     //2.声明Season对象的属性：private final修饰
  2.     private final String seasonName;
  3.     private final String seasonDesc;
  5.     //2.私有化类的构造器,并给对象属性赋值
  6.     private Season(String seasonName,String seasonDesc){
  7.         this.seasonName = seasonName;
  8.         this.seasonDesc = seasonDesc;
  9.     }
  11.     //4.其他诉求1：获取枚举类对象的属性
  12.     public String getSeasonName() {
  13.         return seasonName;
  14.     }
  16.     public String getSeasonDesc() {
  17.         return seasonDesc;
  18.     }
  19.     //4.其他诉求1：提供toString()

// @Override // public String toString() { // return “Season{“ + // “seasonName=’” + seasonName + ‘\’’ + // “, seasonDesc=’” + seasonDesc + ‘\’’ + // ‘}’; // }

  1.     @Override
  2.     public void show() {
  3.         System.out.println("这是一个季节");
  4.     }
  5. }
  3. - 
  4. 情况二：让枚举类的对象分别实现接口中的抽象方法
  5. ```java
  6. public class SeasonTest1 {
  7.     public static void main(String[] args) {
  8.         Season1 summer = Season1.SUMMER;
  9.         //toString():返回枚举类对象的名称
  10.         System.out.println(summer.toString());
  12. //        System.out.println(Season1.class.getSuperclass());
  13.         System.out.println("****************");
  14.         //values():返回所有的枚举类对象构成的数组
  15.         Season1[] values = Season1.values();
  16.         for(int i = 0;i < values.length;i++){
  17.             System.out.println(values[i]);
  18.             values[i].show();
  19.         }
  20.         System.out.println("****************");
  21.         Thread.State[] values1 = Thread.State.values();
  22.         for (int i = 0; i < values1.length; i++) {
  23.             System.out.println(values1[i]);
  24.         }
  26.         //valueOf(String objName):返回枚举类中对象名是objName的对象。
  27.         Season1 winter = Season1.valueOf("WINTER");
  28.         //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
  29. //        Season1 winter = Season1.valueOf("WINTER1");
  30.         System.out.println(winter);
  31.         winter.show();
  32.     }
  33. }
  35. interface Info{
  36.     void show();
  37. }
  39. //使用enum关键字枚举类
  40. enum Season1 implements Info{
  41.     //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
  42.     SPRING("春天","春暖花开"){
  43.         @Override
  44.         public void show() {
  45.             System.out.println("春天在哪里？");
  46.         }
  47.     },
  48.     SUMMER("夏天","夏日炎炎"){
  49.         @Override
  50.         public void show() {
  51.             System.out.println("宁夏");
  52.         }
  53.     },
  54.     AUTUMN("秋天","秋高气爽"){
  55.         @Override
  56.         public void show() {
  57.             System.out.println("秋天不回来");
  58.         }
  59.     },
  60.     WINTER("冬天","冰天雪地"){
  61.         @Override
  62.         public void show() {
  63.             System.out.println("大约在冬季");
  64.         }
  65.     };
  67.     //2.声明Season对象的属性:private final修饰
  68.     private final String seasonName;
  69.     private final String seasonDesc;
  71.     //2.私有化类的构造器,并给对象属性赋值
  73.     private Season1(String seasonName,String seasonDesc){
  74.         this.seasonName = seasonName;
  75.         this.seasonDesc = seasonDesc;
  76.     }
  78.     //4.其他诉求1：获取枚举类对象的属性
  79.     public String getSeasonName() {
  80.         return seasonName;
  81.     }
  83.     public String getSeasonDesc() {
  84.         return seasonDesc;
  85.     }
  86. }

2. 注解的使用

主要内容：

  • 注解(Annotation)概述
  • 常见的Annotation示例
  • 自定义Annotationn
  • JDK中的元注解
  • 利用反射获取注解信息(在反射部分涉及)
  • JDK8中注解的新特性

2.1. 注解概述

从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是 Annotation(注解)

Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员 可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代 码分析工具、开发工具和部署工具可以通过这些补充信息进行验证 或者进行部署。

Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在 Annotation 的 “name=value” 对中

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

未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以 上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的 Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上 可以说：框架 = 注解 + 反射 + 设计模式。

2.2. 常见注解示例

2.2.1. 示例一：生产文档相关的注解

@author 标明开发该类模块的作者，多个作者之间使用,分割

@version 标明该类模块的版本

@see 参考转向，也就是相关主题

@since 从哪个版本开始增加的

@param 对方法中某参数的说明，如果没有参数就不能写

@return 对方法返回值的说明，如果方法的返回值类型是void就不能写

@exception 对方法可能抛出的异常进行说明 ，如果方法没有用throws显式抛出的异常就不能写

其中 ：

  1. [@param ](/param ) [@return ](/return ) 和 [@exception ](/exception ) 这三个标记都是只用于方法的。 
  3. @param的格式要求：[@param ](/param ) 形参名 形参类型 形参说明 
  5. [@return ](/return ) 的格式要求：[@return ](/return ) 返回值类型 返回值说明 
  7. @exception的格式要求：[@exception ](/exception ) 异常类型 异常说明 @param和@exception可以并列多个

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

@Override: 限定重写父类方法, 该注解只能用于方法

@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择

@SuppressWarnings: 抑制编译器警告

2.2.3. 示例三：跟踪代码依赖性，实现替代配置文件功能

例如：以前的写法

  1. <servlet>
  2. <servlet-name>LoginServlet</servlet-name>
  3. <servlet-class>com.servlet.LoginServlet</servlet-class>
  4. </servlet>
  5. <servlet-mapping>
  6. <servlet-name>LoginServlet</servlet-name>
  7. <url-pattern>/login</url-pattern>
  8. </servlet-mapping>

现在的写法：Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署。

  1. @WebServlet("/login")
  2. public class LoginServlet extends HttpServlet {
  3.     private static final long serialVersionUID = 1L;
  4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { }
  5.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
  6. ServletException, IOException {
  7.     doGet(request, response);
  8.     } 
  9. }

2.3. 如何自定义注解

  1. 定义新的 Annotation类型使用@interface 关键字

  2. 内部定义成员，通常使用value表示

  3. 可以指定成员的默认值，使用default定义

  4. 如果自定义注解没有成员，表明是一个标识作用。

  5. 如果注解有成员，在使用注解时，需要指明成员的值

自定义注解必须配上注解的信息处理流程（使用反射）才有意义

  1.     public @interface MyAnnotation{
  2.     //可以指定默认值
  3.     String value() default "hi";
  4.     }
  1. @MyAnnotation(value="hello")
  2. class Person{
  3.     private String name;
  4.     private int age;
  6.     public Person() {
  7.     }
  8.     @MyAnnotation
  9.     public Person(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  13.     @MyAnnotation
  14.     public void walk(){
  15.         System.out.println("人走路");
  16.     }
  17.     public void eat(){
  18.         System.out.println("人吃饭");
  19.     }
  20. }

2.4. JDK提供的4种元注解

JDK 的元 Annotation 用于修饰其他 Annotation 定义。对现有的注解进行解释说明的注解。

JDK5.0提供了4个标准的meta-annotation类型，分别是：

  • Retention

  • Target

  • Documented 用的少

  • Inherited 用的少

2.4.1. @Retention

用于指定该 Annotation 的生命周期, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用 @Rentention 时必须为该 value 成员变量指定值:

RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释，意味着在编译的时候丢弃这个注释

RetentionPolicy.CLASS:在class文件中有效（即class保留） ， 当运行 Java 程序时, JVM 不会保留注解。 这是默认值

RetentionPolicy.RUNTIME:在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会保留注释。程序可以通过反射获取该注释,只有声明为RUNTIME生命周期的注解，才能通过反射获取。

  1.  @Retention(RetentionPolicy.RUNTIME)
  2.  public @interface MyAnnotation{
  3.     //可以指定默认值
  4.     String value() default "hi";
  5.     }

2.4.2. @Target

用于指定被修饰的 Annotation 能用于 修饰哪些程序元素。@Target 也包含一个名为 value 的成员变量。

day22_java枚举类&注解学习笔记 - 图1

  1. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3.  public @interface MyAnnotation{
  4.     //可以指定默认值
  5.     String value() default "hi";
  6.     }

2.4.3. @Documented

表示所修饰的注解在被javadoc解析时，保留下来。默认情况下，javadoc是不包括注解的。

定义为Documented的注解必须设置Retention值为RUNTIME。

2.4.4. @Inherited

被它修饰的 Annotation 将具有继承性。如果某个类使用了被 @Inherited 修饰的 Annotation, 则其子类将自动具有该注解。

2.5. JDK8中注解的新特性

2.5.1. 可重复注解

jdk8之前的写法

  1. public @interface MyAnnotations {
  2.     MyAnnotation[] value();
  3. }
  1. @MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
  2. class Person{
  3.     private String name;
  4.     private int age;
  6.     public Person() {
  7.     }
  8.     @MyAnnotation
  9.     public Person(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  13.     @MyAnnotation
  14.     public void walk(){
  15.         System.out.println("人走路");
  16.     }
  17.     public void eat(){
  18.         System.out.println("人吃饭");
  19.     }
  20. }

jdk8之后的写法

  1. 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
  2. MyAnnotation的Target和Retention等元注解和MyAnnotations相同
  1. @Repeatable(MyAnnotations.class)
  2. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_USE})
  3. @Retention(RetentionPolicy.RUNTIME)
  4.  public @interface MyAnnotation{
  5.     //可以指定默认值
  6.     String value() default "hi";
  7.     }
  1. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_USE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MyAnnotations {
  4.     MyAnnotation[] value();
  5. }

2.5.2. 类型注解

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

  1. @Repeatable(MyAnnotations.class)
  2. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, TYPE_PARAMETER })
  3. @Retention(RetentionPolicy.RUNTIME)
  4.  public @interface MyAnnotation{
  5.     //可以指定默认值
  6.     String value() default "hi";
  7.     }
  1. class Genertic<@MyAnnotation T> {
  3. }

ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

  1. @Repeatable(MyAnnotations.class)
  2. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, TYPE_USE  })
  3. @Retention(RetentionPolicy.RUNTIME)
  4.  public @interface MyAnnotation{
  5.     //可以指定默认值
  6.     String value() default "hi";
  7.     }
  1. class Genertic<@MyAnnotation T> {
  2.     public void show() @MyAnnotation RuntimeException{
  3.         ArrayList<@MyAnnotation String> list = new ArrayList<>();
  4.         int num = (@MyAnnotation int) 10L;
  5.     }
  6. }