注解和反射

一、什么是注解

• Annotation是从JDK5.0开始引入的新技术.

• Annotation的作用:

  • 不是程序本身,可以对程序作出解释.(这一点和注释(comment)没什么区别)

  • 可以被其他程序(比如:编译器等)读取

• Annotation的格式:
  注解是以"@注释名"在代码中存在的,还可以添加一些参数值，例如:@SuppressWarnings(value=“unchecked”).

• Annotation在哪里使用?

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

public class Test01 extends Object {
    //@Override 重写的注解
    @Override
    public String toString() {
        return super.toString();
    }
}

二、内置注解

常见的三个内置注解

• @override:定义在java.lang.Override中, 此注释只适用于修辞方法﹐表示一个方法声明打算重写超类中的另一个方法声明
• @Deprecated :定义在java.lang.Deprecated中,此注释可以用于修辞方法﹐属性﹐类﹐表示不鼓励程序员使用这样的元素,通常是因它很危险或者存在更好的选择
• suppressWarnings:定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息
  • 与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,我们选择性的使用就好了
    @SuppressWarnings(“all”)
    @SuppressWarnings(“unchecked”)
    @SuppressWarnings(value={“unchecked”,“deprecation”})等等…

三、元注解

• 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明
• 这些类型和它们所支持的类在java.lang.annotation包中可以找到.(@Target , @Retention ,@Documented , @Inherited )
  • @Target:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
  • @Retention:表示需要在什么级别保存该注释信息﹐用于描述注解的生命周期(SOURCE< CLASS < RUNTIME)
  • @Document:说明该注解将被包含在javadoc中
  • @lnherited:说明子类可以继承父类中的该注解

import java.lang.annotation.*;

public class Test02 {
    public void test(){

    }
}

//自定义注解
//Target 表示注解可以用到哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//@Retention 表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)
//@Documented 表示是否将注解生成在JAVAdoc中
@Documented
//@Inherited  子类可以继承父类的注解
@Inherited
@interface MyAnnotation{

}

四、自定义注解

使用@interface自定义注解时﹐自动继承了java.lang.annotation.Annotation接口

分析

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

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class Test03 {
    //注解可以显示赋值，如果没有默认值，则必须给注解赋值
    @MyAnnotation2(name="JF")
    public void test2(){}

    @MyAnnotation3("JF")
    public void test3(){}
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数：参数类型 + 参数名
    String name() default ""; //默认值为空
    int age() default 0;
    int id() default  -1;//如果找不到就返回-1，代表不存在
    String[] schools() default  {"广理"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value(); // 只有一个值时建议用value命名
}

五、反射概述

• Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

• 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射

正常方式：引入需要的“包类”名称 -> 通过new实例化 -> 取得实例化对象

反射方式：实例化对象 -> getClass()方法 -> 得到完整的“包类”名称

六、获得反射对象

Java反射机制提供的功能

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理

反射相关的主要API

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

package com.jf.reflection;

/**
 * @Author ：JF
 * @CreatTime ： 2021/9/20 11:30
 * @Description：
 */
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        //一个类在内存中只有一个class对象
        //一个类被加载后，类的整个结构都会被封装在class对象中。

        Class c1 = Class.forName("com.jf.reflection.User");
        System.out.println(c1);
        System.out.println(c1.hashCode());
    }
}

//实体类
class User {
    private String name;
    private int id;
    private int age;

    public User() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

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

七、得到class类的几种方式

• Class本身也是一个类
• Class对象只能由系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的一个class文件
• 每个类的实例都会记得自己是由哪个Class 实例所生成
• 通过Class可以完整地得到一个类中的所有被加载的结构
• Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

class类的常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VmR1CYM8-1632720110280)(注解和反射.assets/image-20210920115122132.png)]

八、分析类初始化

• 类的主动引用(一定会发生类的初始化)
  • 当虚拟机启动，先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员（除了final常量)和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
• 类的被动引用(不会发生类的初始化)
  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量，不会导致子类初始化
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了)

九、类加载器

• 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
• 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象

public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {

        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器 ->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器 -> 根加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器
        ClassLoader classLoader = Class.forName("com.jf.reflection.Test03").getClassLoader();
        System.out.println(classLoader);

    }
}