Java注解与反射

什么是注解

注解，顾名思义就是对某些事物进行标注说明，存放更多的信息。在java层面，注解又叫java标注，java提供了一套机制，使得我们可以对方法、类、参数、包、域以及变量等添加标准(或附加信息，功能也算是信息的一部分)，并且通过某些定义好的实际触发此段信息。

注解的作用

• 对代码的解释和描述，对代码本身运行没有影响。
• 可以被其他程序读取。

注解的格式

注解是以 @注释名 的形式出现的，注解还可以带参数，例如@SuppressWarnings(Value=“unchecked”)
可以附加在package、class、method、field等上面，给它们添加辅助信息，可以通过反射机制编程实现对元数据的访问。

内置注解

• @Overide: 重写注解，表示将重写父类中的方法，如果加了此注解或者重写方法名与父类不符，则报错
• @Deprecated，修饰方法、属性和类，表示不建议使用此种，有更好的选择
• @SuppressWarnings 用来抑制编译时的警告信息（需要一个参数）
  例如： @SuppressWarnings(Value=“unchecked”)
  @SuppressWarnings(“all”)等等。

元注解

元注解的作用是注解其他注解，Java中有四个标准的meta-annotation类型，它们被用来对其他annotation类型做说明：

• @Target ：用来描述注解的使用范围
• @Retention ：表示在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME）
• @Documented :表示该注解将被包含在javadoc中
• @Inherited 说明子类可以继承父类的该注解。

public class Test {
	@MyAnnotation//因为Target的参数为METHOD，可以使用在方法上
public void test() {
	
}
}
//Target表示注解可以用在那些地方（带参）
@Target(value=ElementType.METHOD)
//@Retention 表示注解在什么地方还有效
@Retention(value=RetentionPolicy.RUNTIME)
//@Document  :表示该注解将被包含在javadoc中
@Documented
//@Inherited  说明子类可以继承父类的该注解。
@Inherited
@interface MyAnnotation{
	
}

自定义注解

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

反射

动态语言： 运行过程中可以改变其结构的语言叫做动态语言。
静态语言： 运行过程中不能改变其结构的语言叫做静态语言。
Java语言是静态语言，但其反射机制让其拥有动态语言的特性
反射机制能够允许程序在运行期间借助Reflection的API获取类的内部信息

优点：可以实现动态创建对象和编译，灵活性高。
缺点：降低程序运行的效率。

主要API

反射需要用到的API

获取字节码对象
Class.forName(“类的全路径”);
类名.class
对象.getClass();
3.2 常用方法
获取包名 类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名

获取成员变量定义信息
getFields()//获取所有公开的成员变量,包括继承变量
getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getField(变量名)
getDeclaredField(变量名)

获取构造方法定义信息
getConstructor(参数类型列表)//获取公开的构造方法
getConstructors()//获取所有的公开的构造方法
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)

获取方法定义信息
getMethods()//获取所有可见的方法,包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getDeclaredMethod(方法名,int.class,String.class)

反射新建实例
clazz.newInstance();//执行无参构造创建对象
clazz.newInstance(66,”hh”);//执行含参构造创建对象
clazz.getConstructor(int.class,String.class)//获取构造方法

反射调用成员变量
clazz.getDeclaredField(变量名);//获取变量
clazz.setAccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null

反射调用成员方法
Method m = Clazz.getDeclaredMethod(方法名,参数类型列表);
m.setAccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法

反射的应用

package cn.tedu.review;
/*本类用于复习反射的物料类*/
public class Student {
    //1.定义成员变量
    private String name;
    public int age;

    //2.给被封装属性提供get与set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    //3.生成本类的无参构造与全参构造
    public Student(){}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //4.提供本类的普通方法
    public void play(){
        System.out.println("今天大结局，放学后我要写1W行代码玩玩~");
    }
    public void sunDay(int n){
        System.out.println();
    }
    //5.为了查看学生对象的具体属性与属性值，重写toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

获取类对象

package cn.tedu.reflection;

import org.junit.Test;

import java.lang.reflect.Method;
import java.util.Arrays;

public class TestReflect {
    
    /*单元测试方法：是Java中最小的测试单位，使用灵活，推荐指数：5颗星
    * 语法要求：@Test + public + void + 没有参数
    * 注意：使用时需要导包：Add JUnit 4 library to the build path
    * 导包后的效果：import org.junit.Test
    * 执行方式：选中方法名前绿色的小三角，成功运行会有绿色的小对勾
    * */
    //2.通过单元测试方法，获取目标类Student对应的字节码对象
    @Test
    public void getClazz() throws ClassNotFoundException {
        //练习获取字节码对象的3种方式
        Class<?> clazz1 = Class.forName("cn.tedu.review.Student");
        Class<?> clazz2 = Student.class;
        Class<?> clazz3 = new Student().getClass();

        //打印的是Student类对应的字节码对象
        System.out.println(clazz1);//class cn.tedu.reflection.Student
        //获取当前字节码对象clazz1的名字
        System.out.println(clazz1.getName());//cn.tedu.reflection.Student
        //通过字节码对象，获取Student类的类名
        System.out.println(clazz2.getSimpleName());
        //通过字节码对象，获取Student类对应的包对象
        System.out.println(clazz3.getPackage());
        //通过字节码对象，先获取Student类对应的包对象，再获取这个包对象的名字
        System.out.println(clazz3.getPackage().getName());
    }

获取成员变量

package cn.tedu.reflection;

import java.lang.reflect.Field;

import org.junit.Test;

public class TestReflect {
	//3.通过单元测试方法练习引用类型数组的定义与遍历
    @Test
    public void getStu() {
        //1.创建Student类的3个对象
        Student s1 = new Student("张三", 3);
        Student s2 = new Student("李四", 4);
        Student s3 = new Student("王五", 5);
        //2.创建数组将刚刚的3个对象存入数组中
        Student[] s = {s1, s2, s3};
        //3.直接打印数组，查看数组中的元素
        System.out.println(Arrays.toString(s));
        //4.遍历学生数组，拿到每一个学生对象，做进一步的操作
        for (Student stu : s) {
            //System.out.println(stu);
            stu.play();//通过遍历到的对象，执行play()
            System.out.println(stu.age);//通过遍历到的对象，打印age属性
        }
    }

	//4.通过单元测试方法，获取Student类中的成员变量
    @Test
    public void getFie() throws ClassNotFoundException {
        //1.获取字节码对象
        Class<?> clazz = Class.forName("cn.tedu.review.Student");
        //2.通过字节码对象获取成员变量们
        Field[] fs = clazz.getFields();
        //3.遍历数组，获取每个成员变量的具体信息
        /*注意！目前成员变量的修饰符必须是public的才能获取到，不然，像默认修饰符也是获取不到的*/
        for(Field f : fs){
            System.out.println(f.getName());//通过本轮循环到的字段对象获取字段名
            System.out.println(f.getType());//通过本轮循环到的字段对象获取字段的类型
        }

    }
}

通过字节码对象获取类的成员方法

package cn.tedu.reflection;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.junit.Test;

public class TestReflect {
    //5.通过单元测试方法，获取Student类中的成员方法
    @Test
    public void getFunction() {
        //1.获取字节码对象
        Class clazz = Student.class;
        //2.通过字节码对象获取目标类中的成员方法们
        Method[] ms = clazz.getMethods();
        //3.通过高效for循环遍历数组，拿到每一个方法对象
        for (Method m : ms) {
            System.out.println(m);//直接打印遍历到的方法对象
            System.out.println(m.getName());//通过方法对象获取方法名
            Class[] pt = m.getParameterTypes();//通过方法对象获取方法所有参数的数组
            System.out.println(Arrays.toString(pt));//打印方法参数的数组
        }

    }

通过字节码对象获取类的构造方法

package cn.tedu.reflection;

import java.lang.reflect.Constructor;
import java.util.Arrays;

import org.junit.Test;

public class TestReflect {
    //6.通过单元测试方法，获取Student类中的构造方法
    @Test
    public void getCons() {
        //1.获取字节码对象
        Class clazz = new Student().getClass();
        //2.通过字节码对象获取目标类Student的构造方法们
        Constructor[] cs = clazz.getConstructors();
        //3.通过高效for循环遍历数组
        for(Constructor c : cs){
            System.out.println(c.getName());//打印本轮遍历到的构造方法的名字
            Class[] pt = c.getParameterTypes();//通过本轮遍历到的构造函数对象获取构造函数的参数类型
            System.out.println(Arrays.toString(pt));//打印参数类型
        }
    }

创建对象

package cn.tedu.reflection;

import java.lang.reflect.Constructor;

import org.junit.Test;

public class TestReflect {
//7.通过单元测试方法，创建Student目标类的对象
    @Test
    public void getObject() throws Exception {
        //1.获取字节码对象
        Class clazz = Student.class;
        //2.通过反射技术创建目标类的对象,注意抛出异常
        /*反射创建对象方案1：通过触发目标类的无参构造创建对象*/
        Object o = clazz.newInstance();
        System.out.println(o);//这一步已经获取到了对象Student{name='null', age=0}

        /*反射创建对象方案2：通过触发目标类的全参构造创建对象
        * 思路：
        * 1.先获取指定的构造函数对象,注意需要指定构造函数的参数，传入的是.class字节码对象
        * 2.通过刚刚获取到的构造函数对象创建Student目标类的对象，并且给对象的属性赋值
        * */
        //3.获取目标类中指定的全参构造
        Constructor<?> c = clazz.getConstructor(String.class, int.class);
        //System.out.println(c);
        //4.通过获取到的构造函数：创建对象+给对象的属性赋值
        Object o2 = c.newInstance("赵六", 6);
        System.out.println(o2);
    }
}