Java 反射机制

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
程序启动时在加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。
我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

一、反射机制概述

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

反射库（reflection library） 提供了一个丰富且精巧的工具类，可以用来编写能够动态操纵Java代码的程序。

反射是Java组件的体系结构。使用反射功能可以使得Java可以操作任意一个类，包括类的所有属性和方法，对于任意一个对象也可以去调用内部的属性和方法，这种动态获取类和对象属性的功能被称为反射机制。

其他博客

1.1、反射机制提供的功能

能够分析类能力的程序成为反射（reflective）。反射机制的功能极其强大，功能列表：

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

1.2、反射相关的主要API

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

二、使用反射创建对象

首先创建一个 Person 实体类，然后通过比较常规的方法实例化对象和通过反射实例化对象的过程，初步对反射机制有了解。

2.1、Person 实体类

public class Person {
  private String name;
  public int age;
//getXX()、setXX()、toString()
  public Person() {
  }
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  private Person(String name) {
    this.name = name;
  }
  public void show(){
    System.out.println("你好");
  }
  private String showNation(String nation){
    System.out.println("我的国籍：" + nation);
    return nation;
  }
}

2.2、正常方式和反射方式实例化对象比较

import org.junit.Test;
public class ReflectionTest {
//反射之前，对于Person的操作
  @Test
  public void test(){
//1.创建类的对象
    Person p1 = new Person("jay",21);
//2.调用对象,调用其内部的属性和方法
    p1.age = 15;
    p1.show();
//在Person类的外部，不可以通过Person类的对象调用其内部私有的结构。
  }
##################################################
//反射之后 ，堆与Person的操作
  @Test
  public void test2() throws NoSuchMethodException, IllegalAccessException,
	InvocationTargetException, InstantiationException, NoSuchFieldException {
    Class clazz = Person.class;
//1.通过反射，创建Person类的对象
    Constructor cons = clazz.getConstructor(String.class,int.class);
    Object obj = cons.newInstance("Jon",18);
    Person p = (Person) obj;
    System.out.println(p.toString());
//2.通过反射，调用对象指定的属性和方法
//调用属性
    Field age = clazz.getDeclaredField("age");
    age.set(p,10);
    System.out.println(p.toString());
//调用方法
    Method show = clazz.getDeclaredMethod("show");
    show.invoke(p);
  }
}

三、反射的强大：调用类的私有结构

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionTest {
  @Test
  public void test2() throws Exception{
    Class clazz = Person.class;
//通过反射，是可以调用Person类的私有结构的。
比如：私有的构造器、方法、属性
//调用私有的构造器
    Constructor cons2 = clazz.getDeclaredConstructor(String.class);
    cons2.setAccessible(true);
    Person p1 = (Person) cons2.newInstance("kalo");
    System.out.println(p1);

//调用私有的属性
    Field name = clazz.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p1,"Taoyao");
    System.out.println(p1);

 //调用私有的方法
    Method showNation = clazz.getDeclaredMethod("LiNin", String.class);
    showNation.setAccessible(true);
    String nation = (String) showNation.invoke(p1,"FaceBook");
    //相当于String nation = p1.showNation("FaceBook")
    System.out.println(nation);
  }
}