java反射获得域_Java反射总结

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 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 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 clazz = null;

clazz = InnerTest.class;

Constructor c1 = null;

Constructor c2 = null;

Constructor 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 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 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;

}