java 反射和注解

反射与注解

1、反射（reflection)

1、反射概述

能够分析类能力的程序称为反射；
java 被视为准动态语言关键就是因为有了反射机制；
java 可以通过Reflection API 取得任何类的内部信息(包括类名、字段、方法、接口 ... ），并能直接操作任意对象的内部属性及方法；
- ```
Class c = Class.forName("java.lang.String")
```
加载完类之后，会在堆内存的方法区中产生一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类结构信息。我们可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们称之为：反射：
- 正常方式：引入需要的“包类”名称 --> 通过new实例化 --> 取得实例对象
- 反射方式：实例化对象 --> getClass（）方法 --> 得到完整的“包类” 名称

2、反射的优缺

优点：可以实现动态创建对象和编译，体现了很大的灵活性；
缺点：
- 对性能有影响：使用反射基本上是一种解释操作，我们可以告诉jvm，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作；
- 安全性降低；

3、反射相关的主要API

java.lang.Class : 代表一个类
java.lang.reflect.Method : 代表类的方法
java.lang.reflect.Field : 代表类的成员变量
java.lang.reflect.Contructor : 代表类的构造器
...

public class Reflection01 {

    public static void main(String[] args) throws ClassNotFoundException {
        // 通过反射获取类的class对象
        Class c1 = Class.forName("com.object.User");
        Class c2 = Class.forName("com.object.User");
        Class c3 = Class.forName("com.object.User");
        Class c4 = Class.forName("com.object.User");

        // 打印的class 对象都是同一个对象，一个类在内存中只有一个class对象（保存在方法区中）
        // 一个类被加载后，类的整个结构都会被封装在class 对象中（反射对象）
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}

//实体类 （pojo 、 entity类）
class User{
    private String name;
    private int age;
    private int id;

    public User() {
    }
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int getId() {
        return id;
    }

    public User(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
}

3、反射机制功能

在运行时分析类的能力；
在运行时检查对象，例如，编写一个适用于所有类的toString 方法；
实现泛型数组操作代码；
利用Method 对象，这个对象很像C++ 中的函数指针；

4、Class 类

Class 本身也是一个类；并且Class 对象只能由系统创建，我们只能通过方法去获取这个对象；
一个类只有一个Class 对象；
一个Class 对象对应的是一个加载到JVM中的 .class 文件；
每个实例（对象）都会 "记得" 自己是由哪个Class对象所生成的；
通过Class 可以完整地得到一个类（其他类）中所有被加载的结构；
Class 类是Reflection 的根源，针对任何你想动态加载、运行的类，唯有先获得相对应的Class 对象；
获取Class 对象的三种方法：
- 实例对象调用 .getClass() 方法可以得到一个实例对象的Class类型的对象；
```
Class a = person.getClass();
```
- 类名调用 .class 方法；（一般这种方式最长用，安全性最高，程序性能最高）
```
Class<Student> studentClass = Student.class;
```
- Class.forName("类路径") ；
```
Class<?> aClass1 = Class.forName("com.ze.controller.Student");
```

public class Reflection02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person02 p1 = new Student02();
        System.out.println("这个人是："+p1.name);
        System.out.println(p1.toString());

        // 一：通过对象获取
        Class p2 = p1.getClass();

        // 二：通过forName 获取
        Class p3 = Class.forName("com.object.Student02");

        // 三：通过类名获取
        Class p4 = Student02.class;

        // 四：基本内置类型的包装类都有一个Type 属性
        Class type = Integer.TYPE;

        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());
        System.out.println(p4.hashCode());
        System.out.println(type);

        // 获得父类的类型
        Class superP2 = p2.getSuperclass();
        System.out.println(superP2);
    }
}

// 创建一个父类
class Person02{
    String name;

    public Person02(String name) {
        this.name = name;
    }

    public Person02() {
    }

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


// 学生子类继承父类Person02
class Student02 extends Person02{

    public Student02() {
        this.name = "学生";
    }
}

// 老师子类继承父类Person02
class Teacher02 extends Person02{
    public Teacher02() {
        this.name = "老师";
    }
}

Class对象会描述一个特定类的属性；
Class类方法:
- getName - 返回此Class对象所表示的实体（类，接口，数组类或void）的名字（如果类在一个包里，包的路径名字也会作为类名一部分）
- getPackage - 得到这个类型的包的包名，如果这个类型是数组类型，则返回元素类型的所属包，如果这个类型是基本类型，则返回"java.lang";
- static ClassforName(String name) - 返回指定的类名name的Class 对象；
- Object newInstance() - 调用缺省构造函数，返回Class对象的一个实例；
- Class getSuperClass() - 返回当前Class对象的父类的Class对象；
- Class[] getinterfaces() - 获取当前Class对象的接口；
- ClassLoader getClassLoader() - 返回该类的类加载器；
- Constructor[] getConstructor() - 返回一个包含Constructor对象的数组；
- Method getMothed(String name,Class.. T) - 返回一个Method对象，此对象的形参类型为param Type
- Field[] getDeclaredFields() - 返回Field 对象的一个数组；
哪些类型可以有Class 对象
- class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类；
- interface ：接口
- [] ：数组
- enum ：枚举
- annotation ：注解@interface
- primitive type ：基本数据类型
- void

//基本所有的类都会有Class 对象
public class Reflection03 {
    public static void main(String[] args) {
        // Object的class类对象
        Class c1 = Object.class;
        // 接口的class对象
        Class c2 = Comparable.class;
        // 字符串数组的class对象
        Class c3 = String[].class;
        // 数组的class对象
        Class c4 = int[][].class;
        // 注解的class 对象
        Class c5 = Override.class;
        // 枚举类的class 对象
        Class c6 = ElementType.class;
        // 基本数据包装类的 class 对象
        Class c7 = Integer.class;
        // 基本数据类型的 class 对象
        Class c8 = int.class;
        // void的class 对象
        Class c9 = void.class;
        // Class类的 类对象
        Class c10 = Class.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
        System.out.println(c10);

        // 对象对应的类的类型一样，那么他们获取的Class类对象就是同一个
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
        System.out.println(a.getClass() == b.getClass());
    }
}

5、类加载过程

类的加载（Load）：将类的class文件读入内存，并创建一个java.lang.Class 对象，此过程由类加载器完成；
- 将class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构；
- 然后生成一个代表这个类的 java.lang.Class 对象；
类的链接（Link）：将类的二进制数据合并到JRE中
- 验证：确保加载的类信息符合JVM规范，没有安全方面的问题；
- 准备：正式为类变量（static）分配内存空间，并设置类变量的初始值，这些内存都是在方法区进行分配；
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程；
初始化（Initialize）：JVM 负责对类进行初始化
- 执行类构造器（）方法的过程。类构造器() 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的（类构造器是构造类信息的，不是构造该类对象的构造器）；
- 当初始化一个类的时候，如果发现其父类还没有初始化，则需要先触发父类的初始化；
- 虚拟机会保证一个类的() 方法在多线程环境中被正确加锁和同步；

public class Reflection04 {

    public static void main(String[] args) {
        AA aa = new AA();
        System.out.println(AA.m); // 直接通过类调用类变量，是不会进行构造器的
        /*
        * 1、将类加载到内存中，会产生一个对应的Class对象；
        * 2、链接，链接结束后 m = 0；
        * 3、初始化：（合并静态代码）
        *   <clinit>{
                        System.out.println("AA类静态代码块初始化");
                        m = 300;  
        *               m = 100;
        *           }
        * */
    }
}

class AA{
    public AA() {
        System.out.println("AA的构造器");
    }

    /*
    * m = 300;
    * m = 100;
    * */
    static {
        System.out.println("AA类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
}

内存分析图：

1640006981305

6、类加载器

类加载器就是将class文件字节码（.class 文件）内容加载到内存中，并将这些静态的数据转换成方法区运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class 对象，作为方法区中类数据的访问入口；
类加载器的分类
- 引导类加载器 - Bootstap Classloader : 是使用C++编写的，是JVM自带的类加载器，负责java平台核心类库，用来装载核心类库 - 该加载器无法直接获取；
- 扩展类加载器 - Extension Classloader : 负责 jre/lib/ext 目录下的jar包或 -D java.ext.dirs 指定目录下的jar包装入工作库；
- 系统类加载器 - System Classloader : 负责java -classpath 或 -D java.class.path 所指定的目录下的类与jar包装入工作，是最常用的加载器；
- 自定义类加载器 - 用户自定义，但是不能定义与系统类一样的冲突类，因为java会自动检查，用户自定义类与java自有的类冲突，会无效，系统会自动调用java自有的类；

1640008209448

7、反射机制最重要的功能 - 检查类结构

Class类的 getFields 方法
- 返回这个类的公共字段（属性）的数组和父类的公员
Class类的 getMethods 方法
- 返回这个类的公共方法的数组和父类的公员
Class类的 getConstructors 方法
- 返回构造器的公共数组和父类的公员

Class类的 getDeclareFields 方法
- 返回这个类或接口的所有（包括私有的成员、受保护成员、包成员）字段（属性）的数组 但不包括父类的公员
Class类的 getDeclareMethods 方法
- 返回这个类或接口的方法的所有（包括私有的成员、受保护成员、包成员）数组 但不包括父类的公员
Class类的 getDeclareConstructors 方法
- 返回类或接口构造器的所有（包括私有的成员、受保护成员、包成员）数组 但不包括父类的公员

public class Reflection05 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.object.User");
        // 获得类名
        System.out.println(c1.getName()); // 获得包名+类名
        System.out.println(c1.getSimpleName()); // 获得类名

        // 获得类的属性
        System.out.println("````````````````````````````````````````````````");
        Field[] fields = c1.getFields(); // 获取public属性，如果属性是private的，那么就不能获取
        for (Field field : fields) {
            System.out.println(field);
        }

        Field[] declaredFields = c1.getDeclaredFields(); // 可以获取全部的属性
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

//        Field name1 = c1.getField("name"); // 获取指定 public属性
//        System.out.println(name1);
        Field name2 = c1.getDeclaredField("name"); // 获取指定属性（private）也可以获取
        System.out.println(name2);

        // 获得类的方法
        System.out.println("````````````````````````````````````````````````");
        Method[] methods = c1.getMethods(); // 获取本类和父类的所有public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        Method[] declaredMethods = c1.getDeclaredMethods(); // 获取本类的所有方法，包括private 方法
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //获取指定的public方法
        Method method1 = c1.getMethod("getName",null);
        Method method2 = c1.getMethod("setName", String.class);
        //获取指定的private方法
        Method getName = c1.getDeclaredMethod("getName", null);


        // 获取构造器
        System.out.println("````````````````````````````````````````````````");
        Constructor[] constructors = c1.getConstructors(); // 获取全部public构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        Constructor[] declaredConstructors = c1.getDeclaredConstructors(); // 获取全部（包括private)的构造器方法
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println("全部构造方法："+declaredConstructor);
        }

        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        System.out.println("获取指定的构造器："+constructor);
    }
}

8、反射创建对象，操作对象

反射可以在运行时获取对象的值
反射可以在运行时修改对象的值
- 如果对象的权限是private 时候
  - 反射机制默认行为受到java的访问控制
  - 但是，可以调用Field、Method或Constructor 对象的setAccessible 方法覆盖 java的访问控制；

// 通过反射获取对象，操作构造器，属性，方法
public class Reflection06 {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException {
        // 获得class对象
        Class c1 = Class.forName("com.object.User");

        //构造一个对象
        User user = (User) c1.newInstance(); // 通过newInstance方法构造对象，本质也是调用了user的无参构造器
        System.out.println(user);
        // 通过构造器创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user01 = (User) declaredConstructor.newInstance("有参构造器创建对象", 001, 18);
        System.out.println(user01);

        // 通过反射调用普通方法
        User user02 = (User) c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        // 通过invoke方法激活我们获取的方法，参数是我们激活的方法的对象 和 方法的参数
        setName.invoke(user02,"测试方法设置");
        System.out.println(user02.getName());

        // 通过反射获取对象的属性
        User user03 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true); // 这个方法表示打开权限设置（取消安全检测）；就可以操作对象的private属性
        name.set(user03,"测试字段赋值");
        System.out.println(user03.getName());
    }
}

setAccessible() 方法
- Mehtod 、Field 和 Constructor 对象都有setAccessible() 方法；
- setAccessible 作用是启动和禁用访问安全检查的开关；
- 参数值为true 则表示反射的对象在使用是取消java语言访问检查；
  - 提高了反射的效率，如果代码中必须用反射，该句代码需要频繁的被调用，那么请设置为true；
  - 使原本无法访问的私有成员也可以访问；
- 参数值false则指示反射的对象应该实施java 语言访问检查；

9、使用反射操作泛型

java中采用泛型擦除的机制来引入泛型，java中的泛型仅仅是给编译器javac使用的：确保数据的安全性和免去强制类型转换的问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除；
为了通过反射操作这些泛型，java新增了 ParmmeterizedType,GenericArrayType,TypeVariable 和 WildcardType 几种类型来代表不能被归一到Class类中的类型，但是又和原始类型齐名的类型；
- ParmmeterizedType : 表示一种参数化类型，比如Collection
- GenericArrayType : 表示一种元素类型是参数化类型或者类型变量的数组类型；
- TypeVariable ：是各种类型变量的公共父接口
- WildcardType : 代表一种通配符类型表达式

// 通过反射获取泛型
public class Reflection07 {

    public static void main(String[] args) throws NoSuchMethodException {

        // 通过反射获取方法对象
        Method test01 = Reflection07.class.getMethod("test01", Map.class, List.class);
        // 通过方法对象获取方法上的泛型参数类型（参数可能有多个，所以是个数组列表）
        Type[] genericParameterTypes = test01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            if (genericParameterType instanceof ParameterizedType){ //判断这个泛型的参数类型是否等于结构化参数类型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();// 获取真实的参数信息
                for (Type actualTypeArgument : actualTypeArguments) { // 打印出这些参数信息
                    System.out.println(actualTypeArgument);
                }
            }
        }

        Method test02 = Reflection07.class.getMethod("test02");
        // 通过方法对象获取 方法返回值的泛型参数类型
        Type genericReturnType = test02.getGenericReturnType();
        // 直接对返回值参数类型进行判断(因为返回值是一个）
        if (genericReturnType instanceof ParameterizedType){
            // 获取真实参数类型
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            // 遍历打印这些参数类型
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }

    }

    // 设置泛型方法一
    public void test01(Map<String,User> map, List<User> list){
        System.out.println("test01");
    }

    // 设置泛型方法二
    public Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }
}

10、反射操作注解

getAnnotations
getAnnotation

// 通过反射操作注解
public class Reflection08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.object.Student03");

        // 通过反射获取类上所有的注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        // 通过反射获取类上指定的注解
        Table01 annotation = (Table01) c1.getAnnotation(Table01.class);
        // 通过.value()方法获取注解上的值
        String value = annotation.value();
        System.out.println(value);

        // 获取属性上的注解
        System.out.println("-----------------------------");
        Field f = c1.getDeclaredField("name");
        // 获取字段上注解的对象
        Field01 annotation1 = f.getAnnotation(Field01.class);
        // 获取注解的值
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }
}

// 自定义类上的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table01{
    String value();
}
// 自定义属性上的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field01{
    String columnName();
    String type();
    int length();
}



@Table01("tb_student")
class Student03{
    @Field01(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Field01(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Field01(columnName = "db_name",type = "var char",length = 3)
    private String name;

    public void setId(int id) {
        this.id = id;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public Student03() {
    }

    public Student03(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student03{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

2、注解

注解和注释：

注解是可以给程序看；
注释只是为了给人看；

Annotation（注解）是从JDK5.0 开始引入的技术

Annotation 的作用：

不是程序本身，可以对程序作出解释（这一点和注释 comment 没什么区别）
可以被其他程序（比如：编译器）等读取
注解还可以有检查（约束）的作用（对应注解下如果不按规则写代码，就可能会报错）

Annotation 的格式：

注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：
- @SuppressWarnings(value = "unchecked")

Annotation 可以在哪些地方使用？

可以附加在package , class , method , field 等上面 --- 相当于给他们添加了额外的辅助信息；
我们可以通过反射机制编程实现对这些元数据的访问；

内置注解

@Override : 定义在java.lang.Override 中，此注解只适用于修辞方法，表示一个方法声明打算重写父类中的另外一个方法；
@Deprecated : 定义在java.lang.Deprecated 中，此注解可以用于修辞方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为 “它” 很危险，或者存在更好的选择（比如一些已经废弃的老方法被一些新的方式方法代替等）
@SuppressWarning : 定义在java.lang.SuppressWarnings 中，用来抑制编译时的警告信息，与前两个注解有所不同，这个注解需要添加一个参数才能正确的使用，这些参数都是已经定义好的，我们直接选择使用：
- @SuppressWarnings("all")
- @SuppressWarnings("unchecked")
- @SuppressWarnings("value = {"unch,"deprecation"}" )
- 等等 ...

public class Annotation01 extends Object{

    @Override //重写的注解
    public String toString() {
        return "Annotation01{}";
    }


    @Deprecated // 这个注解的意思是：不推荐程序员使用的，但是可以使用（可能是这个方法已经被更好替代）
    public void test1(){
        System.out.println("Deprecated");
    }

    // 镇压警告注解  不建议平时使用
    // 这个注解需要参数，不同参数镇压不同的警告 
    @SuppressWarnings("all")
    public void test02(){
        List list = new ArrayList();
    }
}

元注解

元注解就是负责注解其他注解的注解（注解的注解）
Java 中定义了4个元注解（meta-annotation）类型，他们用于对其他注解作说明；
- @Target : 用于描述注解的使用范围（即被描述的注解可以使用在声明地方）
- @Retention ：表示需要在什么级别保存（有效）该注解信息，用于描述注解的生命周期
  - （SOURCE - 源码级别 < CLASS - 类级别 < RUNTIME - 运行时)
- @Documented : 说明该注解将被包含在 javadoc 中
- @Inherited ：说明子类可以继承父类中的该注解

public class TestAnnotation01 {
    @MyAnnotation // 使用自定义的注解
    public void test01(){
    }
}

// 自定义注解
//（@Target 表示可以使用在类、方法、变量 等等范围）
@Target( value = ElementType.METHOD) // 表示这个注解可以使用在方法上

// @Retention 表示我们的注解在什么级别才有效 （SOURCE - 源码级别 < CLASS - 类级别 < RUNTIME - 运行时)
@Retention( value = RetentionPolicy.RUNTIME) // 表示这个自定义注解在运行时候有效，大部分自定义注解都是选择 runtime 参数

// @Documented 表示是否将我们的注解生成在 javadoc 文档中
@Documented

// Inherited 表示子类可以继承父类的注解
@Inherited
@interface MyAnnotation{

}

自定义注解

@interface 用来声明一个注解，格式：public@interface 注解名
其中的每一个方法实际上都是声明一个配置参数；
方法的名称就是参数的名称
返回值类型就是参数的类型（返回值只能是基本类型，Class , String , enum )
可以通过 default 来声明参数的默认值
如果只有一个参数成员，一般参数名为 value
注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

// 自定义注解
public class Annotation02 {

    // 1、如果自定义注解没有参数，那么注解后面不用加上参数；
    // 2、如果自定义注解后面有参数，必须在注解后面加上参数；
    // 3、如果自定义注解又默认参数，也可以不用加参数
    @MyAnnotation01( name = "自定义注解", schools = "测试大学") // 括号里面就是注解参数
    public void test01(){

    }
    
    // 如果注解里面只有一个value的值，那么参数可以直接填写，不用写参数名；
    // 注意：只用当注解中一个值，且是用value 命名的；
    @MyAnnotation02("测试")
    public void test02(){
        
    }
}

@Target( {ElementType.METHOD,ElementType.TYPE})
@Retention( value = RetentionPolicy.RUNTIME)
@interface MyAnnotation01{
    // 注解的参数：参数类型 + 参数名（）
    String name(); // 注意：这个不是方法，而是自定义注解的参数（属性）格式就是要加小括号的；

    // 设置注解参数为默认值
    String test() default ""; //使用的default 而不是 = ;
    int age() default 0;
    int id() default -1; // 如果默认值为-1，代表不存在；

    // 参数类型可以是字符串数组
    String[] schools();
    // 设置默认字符串数组
    String[] grade() default {"一年级","二年级","三年级"};
}

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation02{
    String value();
}

注解的使用：
- 直接在方法、类、变量上使用@+定义的注解名；
- 使用反射去读取注解；

posted @ 2021-12-21 15:00 Mxiansheng泽阅读(273) 评论(0) 收藏举报

刷新页面返回顶部

Mxiansheng泽

java 反射和注解

反射与 注解

1、反射（reflection)

1、反射概述

2、反射的优缺

3、反射相关的主要API

3、反射机制功能

4、Class 类

5、类加载过程

6、类加载器

7、反射机制最重要的功能 - 检查类结构

8、反射创建对象，操作对象

9、使用反射操作泛型

10、反射操作注解

2、注解

内置注解

元注解

自定义注解

公告

反射与注解