11.1 枚举类
- 类的对象只有有限个，确定的，如星期、性别、季节等，我们称此类为枚举类。
- 当需要定义一组常量时，强烈建议使用枚举类。
- 如果枚举类中只有一个对象，则可以作为单例模式的实现方式。
- 方式一：JDK5.0之前，自定义枚举类。
- 方式二：JDK5.0，可以使用enum关键字定义枚举类。
11.1.1 如何自定义枚举类
步骤：
声明对象的属性：private final修饰；
私有化类的构造器，并给对象属性赋值；
提供当前枚举类的多个对象：public static final修饰；
其他诉求1：获取枚举类对象的属性；
其他诉求2：toString()方法
import org.junit.jupiter.api.Test; // 自定义枚举类 class Season { // 1、声明Season对象的属性：private final修饰 private final String seasonName; private final String seasonDesc; // 2、私有化类的构造器，并给对象的属性赋值 private Season(String seasonName, String seasonDesc) { this.seasonName = seasonName; this.seasonDesc = seasonDesc; } // 3、提供当前枚举类的多个对象：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("冬天", "冰天雪地"); // 4、其他诉求1：获取枚举类对象的属性 public String getSeasonName() { return seasonName; } public String getSeasonDesc() { return seasonDesc; } // 5、其他诉求2：toString()方法 @Override public String toString() { return "Season{" + "seasonName='" + seasonName + '\'' + ", seasonDesc='" + seasonDesc + '\'' + '}'; } } public class SeasonTest { @Test public void test() { Season spring = Season.SPRING; System.out.println(spring); } }11.1.2 如何使用关键字enum定义枚举类
步骤：
提供当前枚举类的对象，多个对象之间用“,”隔开，末尾的对象“;”结束；
声明Season对象的属性：private final修饰；
私有化类的构造器，并给对象的属性赋值；
其他诉求1：获取枚举类对象的属性。
import org.junit.jupiter.api.Test; // 使用enum关键字定义枚举类 enum Season { // 1、提供当前枚举类的对象，多个对象之间用“,”隔开，末尾的对象“;”结束 SPRING("春天", "春暖花开"), SUMMER("夏天", "夏日炎炎"), AUTUMN("秋天", "秋高气爽"), WINTER("冬天", "冰天雪地"); // 2、声明Season对象的属性：private final修饰 private final String seasonName; private final String seasonDesc; // 3、私有化类的构造器，并给对象的属性赋值 private Season(String seasonName, String seasonDesc) { this.seasonName = seasonName; this.seasonDesc = seasonDesc; } // 4、其他诉求1：获取枚举类对象的属性 public String getSeasonName() { return seasonName; } public String getSeasonDesc() { return seasonDesc; } } public class SeasonTest { @Test public void test() { Season summer = Season.SUMMER; System.out.println(summer); //SUMMER System.out.println(Season.class.getSuperclass()); //class java.lang.Enum } }
enum定义的枚举类的父类是：class java.lang.Enum。
11.1.3 Enum类的主要方法
package java.lang;
public abstract class Enum<E extends Enum<E>> implements Constable, Comparable<E>, Serializable {
private final String name;
public final String name() {
return name;
}
private final int ordinal;
public final int ordinal() {
return ordinal;
}
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
public String toString() {
return name;
}
public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {
T result = enumType.enumConstantDirectory().get(name);
if (result != null)
return result;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException(
"No enum constant " + enumType.getCanonicalName() + "." + name);
}
public static final class EnumDesc<E extends Enum<E>>
extends DynamicConstantDesc<E> {
private EnumDesc(ClassDesc constantType, String constantName) {
super(ConstantDescs.BSM_ENUM_CONSTANT, requireNonNull(constantName), requireNonNull(constantType));
}
public static<E extends Enum<E>> EnumDesc<E> of(ClassDesc enumClass, String constantName) {
return new EnumDesc<>(enumClass, constantName);
}
}
}- toString()：返回当前枚举类对象常量的名称。
- static values()：返回枚举类型的对象数组。
- static valueOf(String objName)：返回枚举类中对象名是objName的对象。如果没有objName的枚举类对象，则抛异常：IllegalArgumentException。
11.1.4 实现接口的枚举类
情况一：实现接口，在enum类中实现抽象方法。
import org.junit.jupiter.api.Test; interface Info { void show(); } // 使用enum关键字定义枚举类 enum Season implements Info { // 1、提供当前枚举类的对象，多个对象之间用“,”隔开，末尾的对象“;”结束 SPRING("春天", "春暖花开"), SUMMER("夏天", "夏日炎炎"), AUTUMN("秋天", "秋高气爽"), WINTER("冬天", "冰天雪地"); // 2、声明Season对象的属性：private final修饰 private final String seasonName; private final String seasonDesc; // 3、私有化类的构造器，并给对象的属性赋值 private Season(String seasonName, String seasonDesc) { this.seasonName = seasonName; this.seasonDesc = seasonDesc; } // 4、其他诉求1：获取枚举类对象的属性 public String getSeasonName() { return seasonName; } public String getSeasonDesc() { return seasonDesc; } @Override public void show() { System.out.println("这是一个季节"); } } public class SeasonTest { @Test public void test() { Season summer = Season.SUMMER; summer.show(); //这是一个季节 } }情况二：让枚举类的对象分别实现接口中的抽象方法。
import org.junit.jupiter.api.Test; 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("大约在冬季"); } }; // 2、声明Season对象的属性：private final修饰 private final String seasonName; private final String seasonDesc; // 3、私有化类的构造器，并给对象的属性赋值 private Season(String seasonName, String seasonDesc) { this.seasonName = seasonName; this.seasonDesc = seasonDesc; } // 4、其他诉求1：获取枚举类对象的属性 public String getSeasonName() { return seasonName; } public String getSeasonDesc() { return seasonDesc; } } public class SeasonTest { @Test public void test() { Season summer = Season.SUMMER; summer.show(); //宁夏 } }11.2 注解（Annotation）
11.2.1 注解概述
- 从JDK5.0开始，Java增加了对元数据（MetaData）的支持，也就是Annotation（注解）。
- Annotation其实就是代码里的特殊标记，这些标记可以在编译、类加载、运行是被读取，并执行相应的处理。通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
- Annotation可以像修饰符一样被使用，可以用于修饰包、类、构造器、方法、成员变来跟、参数、局部变量的声明，这些信息被保存在Annotation的“name=value”对中。
- 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
- 未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以上都是基于注解的，Hibernate3.x以后也是基于注解的，注解时一种趋势，一定程度上可以说：框架=注解+反射+设计模式。
11.2.2 常见的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：抑制编译器警告
实例三：跟踪代码依赖性，实现替代配置文件功能
Servlet3.0提供了注解（Annotation），使得不再需要在web.xml文件中进行Servlet的部署。 @WebServlet Spring框架中关于“事务”的管理 @transactional11.2.3 自定义Annotation
public interface Annotation { boolean equals(Object obj); int hashCode(); String toString(); Class<? extends Annotation> annotationType(); }定义新的Annotation类型使用@interface关键字。
自定义注解自动继承了java.lang.annotation.Annotation接口。
Annotation的成员白能量在Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组。
可以在定义Annotation的成员变量时为其指定初始值，指定成员变量的初始值可使用default关键字。
如果只有一个参数成员，建议使用参数名为value。
如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认值。格式是“参数名=参数值”，如果只有一个参数成员，且名称为value，可以省略“value=”。
没有成员定义的Annotation称为标记；包含成员变量的Annotation称为元数据Annotation。
注意：自定义注解必须配上注解的信息处理流程才有意义。
步骤：
注解声明为：@interface；
内部定义成员，通常使用value表示；
可以指定成员的默认值，使用default定义；
如果自定义注解没有成员，表明是一个标识作用。
public @interface MyAnnotation { String[] value(); String[] value2() default "hello"; }
自定义注解通常都会指定两个元注解：@Retention、@Target。
11.2.4 JDK中的元注解
- JDK的元注解：用于修饰其他Annotation定义。
- JDK5.0提供了4个标准的meta-annotation类型，分别是：
- @Retention
- @Target
- @Document
- @Inherited
1、@Retention
package java.lang.annotation;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
RetentionPolicy value();
}只能用于修饰一个Annotation定义。
用于指定该Annotation的生命周期。
@Retention包含一个RetentionPolicy类型的成员变量，使用@Retention时必须为该value成员变量指定值：
RetentionPolicy.SOURCE：在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释。
RetentionPolicy.CLASS：在class文件中有效（即class保留），当运行Java程序时，JVM不会保留注释。这是默认值。
RetentionPolicy.RUNTIME：在运行时有效（即运行时保留），当运行Java程序时，JVM会保留注释。程序可以通过反射获取该注释。
package java.lang.annotation; public enum RetentionPolicy { /** * Annotations are to be discarded by the compiler. */ SOURCE, /** * Annotations are to be recorded in the class file by the compiler * but need not be retained by the VM at run time. This is the default * behavior. */ CLASS, /** * Annotations are to be recorded in the class file by the compiler and * retained by the VM at run time, so they may be read reflectively. * * @see java.lang.reflect.AnnotatedElement */ RUNTIME }2、@Target
package java.lang.annotation; @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { ElementType[] value(); }
用于修饰Annotation定义。
用于指定被修饰的Annotation能用于修饰哪些程序元素。
@Target也包含一个名为value的成员变量ElementType[]。
ElementType：
package java.lang.annotation; public enum ElementType { /** Class, interface (including annotation type), or enum declaration */ TYPE, /** Field declaration (includes enum constants) */ FIELD, /** Method declaration */ METHOD, /** Formal parameter declaration */ PARAMETER, /** Constructor declaration */ CONSTRUCTOR, /** Local variable declaration */ LOCAL_VARIABLE, /** Annotation type declaration */ ANNOTATION_TYPE, /** Package declaration */ PACKAGE, /** * Type parameter declaration * * @since 1.8 */ TYPE_PARAMETER, /** * Use of a type * * @since 1.8 */ TYPE_USE, /** * Module declaration. * * @since 9 */ MODULE }3、@Document
package java.lang.annotation;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}- @Documented用于指定该元注解修饰的Annotation类将被javadoc工具提取成文档。
- 默认情况下，javadoc是不包括注解的。
- 定义为@Documented的注解必须设置@Retention的值为RetentionPolicy.RUNTIME。
4、@Inherited
package java.lang.annotation;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}- 被@Inherited修饰的Annotation将具有继承性。
- 如果某个类使用了被@Inherited修饰的Annotation，则其子类将自动具有该注解。
11.2.5 利用反射获取注解信息
11.2.6 JDK8中注解的新特性
1、可重复注解
JDK8以前：
public @interface MyAnnotations { MyAnnotation[] value(); } //================== public @interface MyAnnotation { String[] value(); }JDK8：
- 在MyAnnotation上声明@Repeatable，成员值为MyAnnotaions.class；
- MyAnnotation的Target、Retention和MyAnnotations相同。
public @interface MyAnnotations { MyAnnotation[] value(); } //=================== import java.lang.annotation.Repeatable; @Repeatable(MyAnnotations.class) public @interface MyAnnotation { String[] value(); }2、类型注解
JDK1.8之后，关于元注解@Target的参数类型ElementType枚举值多了两个：TYPE_PARAMETER、TYPE_USE。
在Java8之前，注解只能是在声明的地方所使用，Java8开始，注解可以应用在任何地方。
ElementType.TYPE_PARAMETER：表示该注解能写在类型变量的声明语句中（如：泛型声明）。
import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(ElementType.TYPE_PARAMETER) public @interface MyAnnotation { String[] value(); } class Generic<@MyAnnotation("default") T> { }ElementType.TYPE_USE：表示该注解能写在使用类型的任何语句中。
import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(ElementType.TYPE_USE) public @interface MyAnnotation { String[] value() default "default"; } @Test public void test() throws @MyAnnotation RuntimeException { ArrayList<@MyAnnotation String> strings = new ArrayList<>(); }
京公网安备 11010502036488号