Java的枚举、注解和反射

Java的枚举、注解和反射

一.枚举

1.介绍和格式

JDK1.5引入了新的类型——枚举。 在JDK1.5 之前，我们定义常量都是： public static fianl… 。很难管理。

1.枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

2.Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。

3.Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 “，”来分割。

4.在枚举类型中定义的常量是该枚举类型的实例。

定义格式：

权限修饰符 enum 枚举名称 { 
实例1,实例2，实例3，实例4; 
}

2.常见方法

Enum是所有Java语言枚举类型的公共基本类（注意Enum是抽象类）

变量和类型	方法	描述
protected Object	clone()	抛出CloneNotSupportedException。
int	compareTo(E o)	将此枚举与指定的订单对象进行比较。
boolean	equals(Object other)	如果指定的对象等于此枚举常量，则返回true。
protected void	finalize()	枚举类不能有finalize方法。
类	getDeclaringClass()	返回与此枚举常量的枚举类型对应的Class对象。
int	hashCode()	返回此枚举常量的哈希码。
String	name()	返回此枚举常量的名称，与其枚举声明中声明的完全相同。
int	ordinal()	返回此枚举常量的序数（它在枚举声明中的位置，其中初始常量的序数为零）。
String	toString()	返回声明中包含的此枚举常量的名称。
static <T extends Enum>T	valueOf(类 enumType, String name)	返回具有指定名称的指定枚举类型的枚举常量。

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Level3.LOW.compareTo(Level3.HIGH));//比较,小跟大比为负数
        System.out.println(Level3.LOW.compareTo(Level3.MEDIUM));
        System.out.println(Level3.HIGH.compareTo(Level3.LOW));
        System.out.println(Level2.LOW.name());//返回此枚举常量的名称
        System.out.println(Level2.LOW.toString());
        System.out.println(Level2.HIGH.ordinal());//返回此枚举常量的序数
        Level2 x = Enum.valueOf(Level2.class, "HIGH");//返回具有指定名称的指定枚举类型的枚举常量。
        System.out.println(x.name());
        Level3.LOW.show();
        Level3.HIGH.show();
    }
    public static void haha(Level2 l){
        switch (l){
            case LOW:break;
            case HIGH:break;
        }
    }
}

3.使用方式

public class Level {
    //jdk1.5以前使用枚举的方式
    public static final Level LOW = new Level(1);
    public static final Level MEDIUM = new Level(50);
    public static final Level HIGH = new Level(100);
    private int levelValue;
    private Level(int levelValue){this.levelValue = levelValue;}
    public int getLevelValue() {return levelValue;}
    public void setLevelValue(int levelValue) {this.levelValue = levelValue;}
}

public enum Level2 {
    LOW(1),MEDIUM(50),HIGH(100);
    private int levelValue;
    private Level2(int levelValue){this.levelValue = levelValue;}
    public int getLevelValue() {return levelValue;}
    public void setLevelValue(int levelValue) {this.levelValue = levelValue;}
}

public enum Level3 implements LShow {
    //常见定义方式
    LOW(){
        @Override
        public void show() {
            System.out.println("低级别");
        }
    }, MEDIUM(){
        @Override
        public void show() {
            System.out.println("中级别");
        }
    }, HIGH(){
        @Override
        public void show() {
            System.out.println("高级别");
        }
    };
}
interface LShow{
    void show();
}

注意：

1. 一旦定义了枚举，最好不要妄图修改里面的值，除非修改是必要的。
2. 枚举类默认继承的是java.lang.Enum类而不是Object类
3. 枚举类不能有子类，因为其枚举类默认被fifinal修饰
4. 只能有private构造方法
5. switch中使用枚举时，直接使用常量名，不用携带类名
6. 不能定义name属性，因为自带name属性
7. 不要为枚举类中的属性提供set方法，不符合枚举最初设计初衷。

二.注解

1.简介

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。

Java 语言中的类、方法、变量、参数和包等都可以被标注。和注释不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义 Java 标注。

主要用于：编译格式检查；反射中解析；生成帮助文档；跟踪代码依赖等。

2.内置注解

1. @Override ：重写—定义在java.lang.Override
2. @Deprecated：废弃—定义在java.lang.Deprecated
3. @SafeVarargs：Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
4. @FunctionalInterface： 函数式接口—Java 8 开始支持，标识一个匿名函数或函数式接口。
5. @Repeatable：标识某注解可以在同一个声明上使用多次—Java 8 开始支持，标识某注解可以在同一个声明上使用多次。
6. @SuppressWarnings：抑制编译时的警告信息。定义在java.lang.SuppressWarnings

有三种使用方式：

• @SuppressWarnings(“unchecked”) 抑制单类型的警告
• @SuppressWarnings(“unchecked”,“rawtypes”) 抑制多类型的警告
• @SuppressWarnings(“all”) 抑制所有类型的警告

参数列表：

关键字	用途	关键字	用途
all	抑制所有警告	null	忽略对null的操作
boxing	抑制装箱、拆箱操作时候的警告	rawtypes	使用generics时忽略没有指定相应的类型
cast	抑制映射相关的警告	restriction	抑制禁止使用劝阻或禁止引用的警告
dep-ann	抑制启用注释的警告	serial	忽略在serializable类中没有声明serialVersionUID变量
deprecation	抑制过期方法警告	static-access	抑制不正确的静态访问方式警告
fallthrough	抑制确在switch中缺失breaks的警告	synthetic-access	抑制子类没有按最优方法访问内部类的警告
finally	抑制fifinally模块没有返回的警告	unchecked	抑制没有进行类型检查操作的警告
hiding	抑制相对于隐藏变量的局部变量的警告	unqualified-field-access	抑制没有权限访问的域的警告
incomplete-switch	忽略没有完整的switch语句	unused	抑制没被使用过的代码的警告
nls	忽略非nls格式的字符

3.元注解

作用在其他注解的注解:

1. @Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。

2. @Documented - 标记这些注解是否包含在用户文档中 javadoc。

3. @Target - 标记这个注解应该是哪种 Java 成员。

4. @Inherited - 标记这个注解是自动继承的。

   1. 子类会继承父类使用的注解中被@Inherited修饰的注解 。

   2. 接口继承关系中，子接口不会继承父接口中的任何注解，不管父接口中使用的注解有没有被@Inherited修饰 。

   3. 类实现接口时不会继承任何接口中定义的注解。

4.自定义注解

4.1.注解架构

1.Annotation与RetentionPolicy 与ElementType 。

每 1 个 Annotation 对象，都会有唯一的 RetentionPolicy 属性；至于 ElementType 属性，则有 1~n个。

2.ElementType(注解的用途类型)

1. 子类会继承父类使用的注解中被@Inherited修饰的注解
2. 接口继承关系中，子接口不会继承父接口中的任何注解，不管父接口中使用的注解有没有被@Inherited修饰
3. 类实现接口时不会继承任何接口中定义的注解"每 1 个 Annotation" 都与 “1～n 个 ElementType” 关联。当 Annotation 与某个 ElementType 关联时，就意味着：Annotation有了某种用途。例如，若一个 Annotation 对象是 METHOD 类型，则该Annotation 只能用来修饰方法。

package java.lang.annotation;
public enum ElementType { 
TYPE, /* 类、接口（包括注释类型）或枚举声明 */ 
FIELD, /* 字段声明（包括枚举常量） */ 
METHOD, /* 方法声明 */ 
PARAMETER, /* 参数声明 */ 
CONSTRUCTOR, /* 构造方法声明 */ 
LOCAL_VARIABLE, /* 局部变量声明 */
ANNOTATION_TYPE, /* 注释类型声明 */
PACKAGE /* 包声明 */
}

3.RetentionPolicy（注解作用域策略）。

“每 1 个 Annotation” 都与 “1 个 RetentionPolicy” 关联。

• 若 Annotation 的类型为 SOURCE，则意味着：Annotation 仅存在于编译器处理期间，编译器处理完之后，该 Annotation 就没用了。 例如，" @Override" 标志就是一个 Annotation。当它修饰一个方法的时候，就意味着该方法覆盖父类的方法；并且在编译期间会进行语法检查！编译器处理完后，"@Override" 就没有任何作用了。
• 若 Annotation 的类型为 CLASS，则意味着：编译器将 Annotation 存储于类对应的 .class 文件中，它是 Annotation 的默认行为。
• 若 Annotation 的类型为 RUNTIME，则意味着：编译器将 Annotation 存储于 class 文件中，并且可由JVM读入。

package java.lang.annotation;
public enum RetentionPolicy { 
SOURCE, /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该 Annotation信息了 */ 
CLASS, /* 编译器将Annotation存储于类对应的.class文件中。默认行为 */ 
RUNTIME /* 编译器将Annotation存储于class文件中，并且可由JVM读入 */ 
}

4.2.注意事项

1.定义的注解，自动继承了java.lang,annotation.Annotation接口

2.注解中的每一个方法，实际是声明的注解配置参数：

• 方法的名称就是 配置参数的名称
• 方法的返回值类型，就是配置参数的类型。只能是：基本类型/Class/String/enum

3.可以通过default来声明参数的默认值

4.如果只有一个参数成员，一般参数名为value

5.注解元素必须要有值，我们定义注解元素时，经常使用空字符串、0作为默认值。

4.3.示例

@MyAnnotation(value = "haha",num = 222)
public class Demo2 {
    public static void main(String[] args) {
    }
    public void add(){
    }
}
//注解是否包含在用户文档中
@Documented
//用途类型
@Target({ElementType.TYPE,ElementType.METHOD})
//保存策略
@Retention(RetentionPolicy.CLASS)
//可以继承
@Inherited
@interface MyAnnotation{
    String value() default "hoho";
    int num() default 12;//default默认值
}

上面的作用是定义一个 Annotation，我们可以在代码中通过 “@MyAnnotation1” 来使用它。@Documented, @Target, @Retention, @interface 都是来修饰 MyAnnotation1 的。含义：

(01) @interface

使用 @interface 定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。

定义 Annotation 时，@interface 是必须的。

注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过interface 定义注解后，该注解不能继承其他的注解或接口。

(02) @Documented

类和方法的 Annotation 在缺省情况下是不出现在 javadoc 中的。如果使用 @Documented 修饰该Annotation，则表示它可以出现在 javadoc 中。

定义 Annotation 时，@Documented 可有可无；若没有定义，则 Annotation 不会出现在 javadoc中。

(03) @Target(ElementType.TYPE)

前面我们说过，ElementType 是 Annotation 的类型属性。而 @Target 的作用，就是来指定Annotation 的类型属性。

@Target(ElementType.TYPE) 的意思就是指定该 Annotation 的类型是 ElementType.TYPE。这就意味着，yAnnotation1 是来修饰"类、接口（包括注释类型）或枚举声明"的注解。

定义 Annotation 时，@Target 可有可无。若有 @Target，则该 Annotation 只能用于它所指定的地方；若没有 @Target，则该 Annotation 可以用于任何地方。

(04) @Retention(RetentionPolicy.RUNTIME)

前面我们说过，RetentionPolicy 是 Annotation 的策略属性，而 @Retention 的作用，就是指定Annotation 的策略属性。

@Retention(RetentionPolicy.RUNTIME) 的意思就是指定该 Annotation 的策略是RetentionPolicy.RUNTIME。这就意味着，编译器会将该 Annotation 信息保留在 .class 文件中，并且能被虚拟机读取。

定义 Annotation 时，@Retention 可有可无。若没有 @Retention，则默认是RetentionPolicy.CLASS。

三.反射

JAVA反射机制是在运行状态中，获取任意一个类的结构 , 创建对象 , 得到方法，执行方法 , 属性 !；这种在运行状态动态获取信息以及动态调用对象方法的功能被称为java语言的反射机制。

3.1.内加载器

Java类加载器（Java Classloader）是Java运行时环境（Java Runtime Environment）的一部分，负责动态加载Java类到Java虚拟机的内存空间中。

java默认有三种类加载器：

1.BootstrapClassLoader（引导启动类加载器）：

嵌在JVM内核中的加载器，该加载器是用C++语言写的，主要负载加载JAVA_HOME/lib下的类库，引导启动类加载器无法被应用程序直接使用。

2.ExtensionClassLoader（扩展类加载器）：

ExtensionClassLoader是用JAVA编写，且它的父类加载器是Bootstrap。是由sun.misc.Launcher$ExtClassLoader实现的，主要加载JAVA_HOME/lib/ext目录中的类库。它的父加载器是BootstrapClassLoader 。

3.App ClassLoader（应用类加载器）：

App ClassLoader是应用程序类加载器，负责加载应用程序classpath目录下的所有jar和class文件。它的父加载器为Ext ClassLoader类通常是按需加载，即第一次使用该类时才加载。由于有了类加载器，Java运行时系统不需要知道文件与文件系统。学习类加载器时，掌握Java的委派概念很重要。

双亲委派模型：如果一个类加载器收到了一个类加载请求，它不会自己去尝试加载这个类，而是把这个请求转交给父类加载器去完成。每一个层次的类加载器都是如此。因此所有的类加载请求都应该传递到最顶层的启动类加载器中，只有到父类加载器反馈自己无法完成这个加载请求（在它的搜索范围没有找到这个类）时，子类加载器才会尝试自己去加载。委派的好处就是避免有些类被重复加载。

3.2.获取Class

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        //第一种方式，通过包名.类名.class 加载类
        Class<Person> c1 = com.java.demo3.Person.class;
        System.out.println(c1);
        //第二种方式，通过类的对象获取类的信息
        Person p = new Person();
        Class<Person> c2 =(Class<Person>) p.getClass();
        System.out.println(c2);
        //第三种方式,知道类的名称
        Class<Person> c3 =(Class<Person>) Class.forName("com.java.demo3.Person");
    }
}

注意：上述的三种方式, 在调用时, 如果类在内存中不存在, 则会加载到内存 ! 如果类已经在内存中存在, 不会重复加载, 而是重复利用 !

3.3.获取Constructor

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Person> pClass = (Class<Person>) Class.forName("com.java.demo3.Person");
        /*
        //找到无参构造方法
        Constructor<Person> c1 = pClass.getConstructor();
        //使用无参构造方法，创建对象
        Person p1 = c1.newInstance();
        System.out.println(p1);
        */
        /*
        //找到包含String name 和 int age的构造方法
        Constructor<Person> c2 = pClass.getConstructor(String.class,int.class);
        //使用这个构造方法，创建对象
        Person p2 = c2.newInstance("haha",19);
        System.out.println(p2);
        */
        Constructor<Person> c3 = pClass.getDeclaredConstructor(String.class);
        c3.setAccessible(true);
        Person p3 = c3.newInstance("yuohohoho");
        System.out.println(p3);
    }
}

3.4.获取Method

public class Demo4 {
    public static void main(String[] args) throws Exception {
        //加载类
        Class c1 = Class.forName("com.java.demo3.Person");
        //获取类的构造方法
        Constructor c = c1.getConstructor();
        //创建了对象
        Object o = c.newInstance();
        //获取类的方法
        Method setName = c1.getMethod("setName", String.class);
        Method setAge = c1.getDeclaredMethod("setAge", int.class);//获取所有方法权限
        setAge.setAccessible(true);//可以访问任何权限的方法
        //参数1，哪个对象要执行setName方法
        //参数2，调用方法时传递的参数 0-n
        setName.invoke(o,"张三");
        setAge.invoke(o,18);
        System.out.println(o);
    }
}

3.5.获取Field

public class Demo5 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("com.java.demo3.Person");
        Constructor ct = c.getConstructor();
        Object o = ct.newInstance();

        Field phoneNumber = c.getField("phoneNumber");
        phoneNumber.set(o,"13838438");
        Field name = c.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"李四");

        System.out.println(o);
    }
}

四.获取注解信息

举个例子：

类Book

import java.util.Objects;
@TableAnnotation("test_Book")
public class Book {
    @ColumnAnnotation(columnName = "id",type = "int",length = "10")
    private int id;
    @ColumnAnnotation(columnName = "name",type = "varchar",length = "50")
    private String name;
    @ColumnAnnotation(columnName = "info",type = "varchar",length = "1000")
    private String info;

    public Book() {    }
    public Book(int id, String name, String info) {
        this.id = id;
        this.name = name;
        this.info = info;}
    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", info='" + info + '\'' +
                '}';}
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return id == book.id &&
                Objects.equals(name, book.name) &&
                Objects.equals(info, book.info);}
    @Override
    public int hashCode() {return Objects.hash(id, name, info);}
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public String getInfo() {return info;}
    public void setInfo(String info) {this.info = info;}
}

类Demo

public class Demo {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("com.java.demo4.Book");
        TableAnnotation ta = (TableAnnotation) c.getAnnotation(TableAnnotation.class);
        String value = ta.value();
        System.out.println("表名:"+value);

        Field[] fs = c.getDeclaredFields();
        for (Field f:fs){
            ColumnAnnotation ca = f.getAnnotation(ColumnAnnotation.class);
            System.out.println(f.getName()+"属性，对应数据库中的字段："+ca.columnName()+"，数据类型："+ca.type()+"，数据长度"+ca.length());
        }
    }
}

注解ColumnAnnotation

@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnAnnotation {
    /**
     * 描述列名
     * @return
     */
    String columnName();
    /**
     * 描述类型
     * @return
     */
    String type();
    /**
     * 描述数据的长度
     * @return
     */
    String length();
}

注解TableAnnotation

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface TableAnnotation {
    /**
     * 用于标注类对应的表格名称
     * @return
     */
    String value();
}

五.内省

基于反射 , java所提供的一套应用到JavaBean的API

一个定义在包中的类 , 拥有无参构造器,所有属性私有, 所有属性提供get/set方法,实现了序列化接口,这种类, 我们称其为 bean类 .

Java提供了一套java.beans包的api , 对于反射的操作, 进行了封装 !

public class Demo1 {
    public static void main(String[] args) throws Exception {
        Class c = Express.class;
        BeanInfo bi = Introspector.getBeanInfo(c);//通过传入的类信息, 得到这个Bean类的封装对象
        PropertyDescriptor[] pds = bi.getPropertyDescriptors();//获取bean类的 get/set方法 数组
        for (PropertyDescriptor pd:pds){
            Method get = pd.getReadMethod();//获取一个get方法
            Method set = pd.getWriteMethod();//获取一个set方法
            System.out.println(get);//
            System.out.println(set);//
            System.out.println(pd.getName());//
            System.out.println(pd.getPropertyType());//
        }
    }
}
 c = Express.class;
        BeanInfo bi = Introspector.getBeanInfo(c);//通过传入的类信息, 得到这个Bean类的封装对象
        PropertyDescriptor[] pds = bi.getPropertyDescriptors();//获取bean类的 get/set方法 数组
        for (PropertyDescriptor pd:pds){
            Method get = pd.getReadMethod();//获取一个get方法
            Method set = pd.getWriteMethod();//获取一个set方法
            System.out.println(get);//
            System.out.println(set);//
            System.out.println(pd.getName());//
            System.out.println(pd.getPropertyType());//
        }
    }
}