注解和反射学习笔记

注解和反射

一、注解 – Annotation

一、什么是注解

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

• Annotation的 作用

​ 是程序本身，可以对程序作出解释。(这一点和注释(comment)没什么区别)

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

• Annotation的 格式

​ 注解是以"@注解名"在代码中存在的，还可以添加一些参数值﹐

​ 例如 : @SuppressWarnings(value=“unchecked”).

• Annotation在哪里使用

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

二、内置注解

• @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 : 用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
  • ElementType.TYPE（类）、METHOD（方法）、…
  • 参数是一个数组，可以同时写多个。–>{ 类型1， 类型2， 类型2，…}
• Retention : 表示需要在什么级别保存该注释信息﹐用于描述注解的生命周期
  • (RetentionPolicy.SOURCE < CLASS < RUNTIME)
• @Document : 说明该注解将被包含在 javadoc 中
• @Inherited : 说明子类可以继承父类中的该注解

四、自定义注解

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

例子：

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation{
    //注解的参数:参数类型+参数名();
    //default 默认值
    //只有1个或其他参数都有默认值时。此参数名推荐用value，此时使用时就可以不写参数名。
    //注意:添加了参数，使用时不写会报错。
     String name ( ) default "";
     int value();
}

分析∶

​ √ interface用来声明一个注解﹐格式: public @interface 注解名 { 定义内容 }。

​ √ 其中的每一个方法实际上是声明了一个配置参数。 如 int value();

​ √ 方法的名称就是参数的名称。

​ √ 返回值类型就是参数的类型（返回值只能是基本类型,Class , String , enum )。

​ √ 可以通过default来声明参数的默认值。

​ √ 如果只有一个参数成员，一般参数名为value。

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

二、反射 – Reflection

前述 ：静态 VS 动态语言

1. 动态语言

   ​ 是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

   ​ 主要动态语言:Object-C、C#、JavaScript、PHP、Python等。

2. 静态语言

   ​ 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如 Java、C、C++。

   ​ Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

一、概述

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

​ Class c= Class.forName(“参数”) 参数可以是包名.类名、类名…

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

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

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

Java反射机制提供的功能 :

1. 在运行时判断任意一个对象所属的类
2. 在运行时构造任意一个类的对象
3. 在运行时判断任意一个类所具有的成员变量和方法
4. 在运行时获取泛型信息
5. 在运行时调用任意一个对象的成员变量和方法
6. 在运行时处理注解
7. 生成动态代理
8. 。。。。。。

二、Class类

1、概述

对象照镜子后可以得到的信息 : 某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。

一个Class对象包含了特定某个结构(class/interface/menum/annotation/primitive type/void/)的有关信息。

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

2.Class类的常用方法：

功能说明
static getclassforName(String name)	返回指定类名name的Class对象
Object newInstance( )	调用缺省构造函数，返回Class对象的一个实例
getName( )	返回此Class对象所表示的实体(类，接口，数组类或void)的名称。
Class getSuperClass( )	返回当前Class对象的父类的Class对象
Class[ ] getinterfaces( )	获取当前Class对象的接口
ClassLoader getClassLoader( )	返回该类的类加载器
Constructor[ ] getConstructors( )	返回一个包含某些Constructor对象的数组
Field[ ] getDeclaredFields( )	返回Field对象的一个数组 , Field类描述的是类的属性信息
Method getMothed(String name,Class… T)	返回一个Method对象，此对象的形参类型为paramType

3.获取Class类的实例（对象）

1. 若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

   Class clazz = Person.class
   

2. 已知某个类的实例，调用该实例的getClass()方法获取Class对象

   Class clazz = person.getClass();
   

3. 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取

   可能抛出 ClassNotFoundException

   Class clazz= Class.forName("demo01.Student");
   

4. 内置基本数据类型可以直接用 类名.Type

5. 还可以利用 ClassLoader

4.类的加载与ClassLoader 的理解

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

5.什么时候会发生类初始化

1. 类的主动引用(一定会发生类的初始化)

   • 当虚拟机启动，先初始化main方法所在的类。
   • new一个类的对象。
   • 调用类的静态成员（除了final常量)和静态方法。
   • 使用java.lang.reflect包的方法对类进行反射调用。
   • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类。

2. 类的被动引用(不会发生类的初始化)

   • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。

     • 如:当通过子类引用父类的静态变量，不会导致子类初始化。

   • 通过数组定义类引用，不会触发此类的初始化。

   • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中)。

6.类加（装）载器的作用

类加载的作用 : 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.langClass对象 ，作为方法区中类数据的访问入口。

类缓存 : 标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

7.有了Class对象,能做什么?

创建类的对象 :

调用Class 对象的 newlnstance( )方法。

• 类必须有一个无参数的构造器。
• 类的构造器的访问权限需要足够

思考 ：

难道没有无参的构造器就不能创建对象了吗 ? 只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。

​ 步骤如下 :

​ 1）通过Class类的getDeclaredConstructor(Class … parameterTypes)

​ 取得本类的指定形参类型的构造器

​ 2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

​ 3）通过Constructor实例化对象

代码示例 ：

package com.lly.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @ClassName:Class_Getxxx
 * @创建者: LLY
 * @创建时间: 2021/5/13 20:48
 * @version: 1.0
 * @描述: 利用反射机制，获取class对象，再利用这个class对象获取一些东西
 * 小提示 ：getDeclaredXxxx(): 是获取所有的Xxxx类型的数据
 *         getXxxx(): 是获取Public的Xxxx类型的数据
 */
public class Class_Getxxx {
    public static void main(String[] args) throws ClassNotFoundException,
            IllegalAccessException, InstantiationException, NoSuchMethodException,
            InvocationTargetException, NoSuchFieldException {
        //1.获得 Person类的 Class对象
        Class c = Class.forName("com.lly.reflection.Person");
        //2.利用这个Class对象，获取Person类的对象
        Person cPerson1 = (Person) c.newInstance();
            //说明默认是调用无参构造器
        System.out.println(cPerson1);//输出: person{name='null', age=null}
        //3.获取构造器
        Constructor Constructor = c.getDeclaredConstructor(String.class,Integer.class);
            //使用此构造器获取Person类的对象
        Person cPerson2 = (Person)Constructor.newInstance("lly",22);
        System.out.println(cPerson2);//Person{name='lly', age=22}
        //4.通过反射调用普通方法
        Method setName = c.getMethod("setName", String.class);
            //给无参构造的获取的person对象赋值: 名字
            //invoke: 激活、执行的意思；参数：（对象，“方法的值”）
        setName.invoke(cPerson1, "八戒");
        System.out.println(cPerson1.getName());
        //5.通过反射操作属性
        Person cPerson3 = (Person) c.newInstance();
        Field name = c.getDeclaredField("name");
        name.setAccessible(true);
        name.set(cPerson3,"猴子");
        System.out.println(cPerson3 );
    }
}

9.反射操作泛型（了解）

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器 javac 使用的,确保数据的安全性和免去强制类型转换问题﹐但是，一旦编译完成﹐所有和泛型有关的类型全部擦除。

为了通过反射操作这些类型, Java新增了ParameterizedType , GenericArrayType ,TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.

• ParameterizedType : 表示一种参数化类型,比如Collection
• GenericArrayType : 表示一种元素类型是参数化类型或者类型变量的数组类型
• TypeVariable : 是各种类型变量的公共父接口
• WildcardType : 代表一种通配符类型表达式

例子 ：

public class GetGenericity {
    public static void main(String[] args) throws NoSuchMethodException {
        Class c1 = GetGenericity.class;
        Method parameterGenericity = c1.getMethod("ParameterGenericity", Map.class);
        //获取通用参数类型
        Type[] genericParameterTypes = parameterGenericity.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("参数类型->"+genericParameterType);
            if (genericParameterType instanceof ParameterizedType){
                //获取参数泛型类型
                ParameterizedType genericParameterType1 = (ParameterizedType) genericParameterType;
                Type[] actualTypeArguments = genericParameterType1.getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println("参数泛型真实类型为-》"+actualTypeArgument);
                }
            }
        }

        Method returnGenericity = c1.getMethod("ReturnGenericity", null);
        //获取通用返回值类型
        Type genericReturnType = returnGenericity.getGenericReturnType();
        System.out.println("返回值类型->"+genericReturnType);
        if (genericReturnType instanceof ParameterizedType){
            //获取返回值泛型类型
            ParameterizedType genericParameterType1 = (ParameterizedType) genericReturnType;
            Type[] actualTypeArguments = genericParameterType1.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println("返回值泛型真实类型为-》"+actualTypeArgument);
            }
        }
    }

    public void ParameterGenericity(Map<String,Person> map) {}
    public ArrayList<String> ReturnGenericity() {
        return new ArrayList<String>();
    }
}

10.反射操作注解

• getAnnotations
• getAnnotation