1、Class对象的获取
Java中对象可以分为两种，一种是实例对象，一种是Class对象。Class对象是在类加载的时候生成的，而实例对象又是基于Class对象来生成的。
Java中的反射使其拥有了动态语言的属性。在程序开发的过程中，反射技术应用的核心就是Class对象的获取。Class对象的获取有如下三种方法，各有各的使用场景。
public class TestReflect {
public static void main(String[] args){
Class<?> clazz1 = null; //Class clazz1 = null;
Class<?> clazz2 = null; //Class clazz2 = null;
Class<?> clazz3 = null; //Class clazz3 = null;
//使用<?>或者不使用<?>两者是没有区别的，只不过Class支持泛型以后加上<?>会更加规范
//1、使用Class的静态方法，该方法会产生异常，需要进行异常处理，因为可能没有与所传入字符串相对应的类
try{
Class clazz1 = Class.forName("InnerTest");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//2、使用Java中类字面量class获得Class对象
Class clazz2 = InnerTest.class;
//3、使用继承于Object的getClass()方法，该方法是native方法
InnerTest innerTest = new InnerTest();
Class clazz3 = innerTest.getClass();
}
}
class InnerTest {
}
2、构造实例对象
获得Class对象之后，采用newInstance()，该方法的返回类型是T，是一个泛型类型。如果Class对象的类型为Class或者Class<?>，则需要强制类型转换。有两种构造实例对象的方法：1、获得Class对象以后调用newInstance()方法；2、获得Constructor对象以后调用newInstance()方法。实际上前者也会调用后者的方法。
import java.lang.reflect.Constructor;
public class TestReflect {
public static void main(String[] args){
//若没有传入类型参数，使用newInstance()方法生成对象的时候，会有两种情况：1、只能生成Object对象；2、进行强制类型转换；
Class<?> clazz1 = null;
//此处传入了类型参数，使用newInstance()方法生成对象的时候，无需进行强制类型转换；
Class<InnerTest> clazz2 = null;
clazz1 = InnerTest.class;
clazz2 = InnerTest.class;
//1、使用newInstance()的方法返回实例对象
try{
Object test11 = clazz1.newInstance();//只能生成Object对象
InnerTest test12 = (InnerTest) clazz1.newInstance();//必须进行强制类型转换
InnerTest test2 = clazz2.newInstance();//直接可以生成所需的类型对象
}catch (IllegalAccessException e) {
e.printStackTrace();
}catch (InstantiationException e){
e.printStackTrace();
}
//2、直接获取构造函数
Constructor<?> c1 = null;
Constructor<InnerTest> c2 = null;
try{
c1 =clazz1.getDeclaredConstructor();
c2 = clazz2.getDeclaredConstructor();
}catch (NoSuchMethodException e) {
e.printStackTrace();
}
try{
Object innerTest11 = c1.newInstance(null);
InnerTest innerTest112 = (InnerTest)c1.newInstance(null);
InnerTest innerTest2 = c2.newInstance(null);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class InnerTest {
}
3、构造方法
在获得Class的对象以后，通过该对象获得对应的构造函数，如果同时存在多个构造函数。
import java.lang.reflect.Constructor;
public class TestReflect {
public static void main(String[] args){
Class<InnerTest> clazz = null;
clazz = InnerTest.class;
Constructor<InnerTest> c1 = null;
Constructor<InnerTest> c2 = null;
Constructor<InnerTest> c3 = null;
try{
c1 = clazz.getDeclaredConstructor();
c2 = clazz.getDeclaredConstructor(int.class);
c3 = clazz.getDeclaredConstructor(int.class,int.class);
}catch (NoSuchMethodException e) {
e.printStackTrace();
}
try{
InnerTest innerTest1 = c1.newInstance();
System.out.println("innerTest1 a: " + innerTest1.a + " b: " + innerTest1.b + " c: " + innerTest1.c);
InnerTest innerTest2 = c2.newInstance(6);
System.out.println("innerTest2 a: " + innerTest2.a + " b: " + innerTest1.b + " c: " + innerTest2.c);
InnerTest innerTest3 = c3.newInstance(6,12);
System.out.println("innerTest3 a: " + innerTest3.a + " b: " + innerTest1.b + " c: " + innerTest3.c);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class InnerTest {
static int a = 2;
int b;
int c;
public InnerTest() {
}
public InnerTest(int b) {
this.b = b;
}
public InnerTest(int b, int c) {
this.b = b;
this.c = c;
}
}
4、非构造方法
非构造方法的获取和使用与构造方法有着明显的区别：1、获取非构造方法不仅需要指定参数的类型，还需要指定方法名；2、非构造方法的调用分为两种情况：a)，静态方法调用；b)，非静态方法调用
import java.lang.reflect.Method;
public class TestReflect {
public static void main(String[] args){
Class<InnerTest> clazz = null;
clazz = InnerTest.class;
try{
//需要指定方法名和参数类型
Method m1 = clazz.getDeclaredMethod("getA");
Method m2 = clazz.getDeclaredMethod("setA", int.class);
//调用静态方法时候，invoke函数的第一个参数为null；
System.out.println(m1.invoke(null));
m2.invoke(null,4);
System.out.println(m1.invoke(null));
InnerTest innerTest = new InnerTest();
Method m3 = clazz.getDeclaredMethod("getB");
Method m4 = clazz.getDeclaredMethod("setB", int.class);
//调用非静态方法的时候，需要指定对象名；
System.out.println(m3.invoke(innerTest));
m4.invoke(innerTest,8);
System.out.println(m3.invoke(innerTest));
}catch (Exception e) {
e.printStackTrace();
}
}
}
class InnerTest {
static int a = 2;
int b;
public static int getA() {
return a;
}
public int getB() {
return b;
}
public static void setA(int a) {
InnerTest.a = a;
}
public void setB(int b) {
this.b = b;
}
}
5、域
域的获取相对简单，只需要传入变量名字。可以获取域的值和设置域的值。更厉害的时候可以通过setAccessible()，进而访问private的变量
import java.lang.reflect.Field;
public class TestReflect {
public static void main(String[] args){
Class<InnerTest> clazz = null;
clazz = InnerTest.class;
try{
Field a = clazz.getDeclaredField("a");
System.out.println("a: " + a.getInt(null));
a.setInt(null,4);
System.out.println("a: " + a.getInt(null));
InnerTest innerTest = new InnerTest();
Field b = clazz.getDeclaredField("b");
System.out.println("b: " + b.getInt(innerTest));
b.setInt(innerTest,20);
System.out.println("b: " + b.getInt(innerTest));
Field c = clazz.getDeclaredField("c");
System.out.println("accessible: " + c.isAccessible());
c.setAccessible(true);
System.out.println("accessible: " + c.isAccessible()+ " c: " +c.getInt(innerTest));
c.setInt(innerTest,40);
System.out.println("accessible: " + c.isAccessible()+ " c: " +c.getInt(innerTest));
} catch (Exception e) {
e.printStackTrace();
}
}
}
class InnerTest {
static int a = 2;
int b = 10;
private int c = 20;
}
