Java中反射机制（Reflection）学习

最新推荐文章于 2023-06-22 19:54:38 发布

Hollivan

最新推荐文章于 2023-06-22 19:54:38 发布

阅读量471

点赞数

分类专栏： JAVA

JAVA 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

首先看下基本概念:

(一)在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

Java 反射机制主要提供了以下功能:

①:在运行时判断任意一个对象所属的类。
②:在运行时构造任意一个类的对象。
③:在运行时判断任意一个类所具有的成员变量和方法。
④: 在运行时调用任意一个对象的方法

反射机制允许程序在运行时通过反射的API获取类中的描述，方法，并且允许我们在运行时改变fields内容或者去调用methods

（二）Java Reflection APIs简介:

在JDK中，主要由以下类来实现Java反射机制，这些类都
位于java.lang.reflect包中
①:Class类：代表一个类。【注:这个Class类进行继承了Object，比较特别】
②:Field 类：代表类的成员变量（成员变量也称为类的属性）。
③:Method类：代表类的方法。
④:Constructor 类：代表类的构造方法。
⑤:Array类：提供了动态创建数组，以及访问数组的元素的静态方法

简要说下是使用方法的步骤:

要想使用使用反射，我们要去获取我们需要进行去处理的类或者对象的Class对象,其中我们主要有三种方法去获取

①:使用Class的静态方法forName():例如:Class.forName("java.lang.Class");

②:使用XXX.Class语法:例如:String.Class；

③:使用具体某个对象.getClass()方法：例如String str="abc"; Class<?> tClass=str.getClass();

先看一个例子:这个例子对于指定的类名，使用反射来获取该类中的所有声明的方法，（使用第一种获取Class对象的方法）(主要代码如下:):

[java] view plain copy print ?

<SPAN style="FONT-SIZE: 14px">package com.jiangqq.reflection;
/**
* 使用反射来获取Class中的生命的方法，包括私有的方法
*/
import java.lang.reflect.Method;
public class Reflection1 {
public static void main(String[] args) throws Exception {
//使用Class去调用静态方法forName()获得java.lang.Class的Class对象
Class<?> tClass = Class.forName("java.lang.Class");
//获取该class中声明的所有方法
Method[] methods = tClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
}
}</SPAN>

package com.jiangqq.reflection;
/**
 * 使用反射来获取Class中的生命的方法，包括私有的方法
 */
import java.lang.reflect.Method;
public class Reflection1 {
	public static void main(String[] args) throws Exception {
		//使用Class去调用静态方法forName()获得java.lang.Class的Class对象
		Class<?> tClass = Class.forName("java.lang.Class");
		//获取该class中声明的所有方法
		Method[] methods = tClass.getDeclaredMethods();
		for (Method method : methods) {
			System.out.println(method);
		}
	}
}

（三）查看Class的API发现Class类是Reflection API 中的核心类，它有以下几个常用的方法

①: getName()：获得类的完整名字。
②: getFields()：获得类的public类型的属性。
③: getDeclaredFields()：获得类的所有属性。
④: getMethods()：获得类的public类型的方法。
⑤: getDeclaredMethods()：获得类的所有方法。

⑥:getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字parameterTypes参数指定方法的参数类型。

⑦:getConstructors()：获得类的public类型的构造方法。

⑧:getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。

⑨:newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

先看上面的⑧和⑨其中都能生成对象，但是因为构造函数有无参和有参构造函数两种,所以我们分两种情况考虑

情况一:如果是无参的构造函数来生成对象:

<a>首先我们去获取Class对象，然后直接通过Class对象去调用newInstance()方法就可以

[java] view plain copy print ?

Class<?> tclass = Reflection2.class;
Object reflection2 = classType.newInstance();

Class<?> tclass = Reflection2.class;
Object reflection2 = classType.newInstance();

<b>首先我们也是去获取Class对象,然后去去调用getConstructor（）得到Constructor对象，接着直接调用newInstance()即可

[java] view plain copy print ?

Class<?> classType = Reflection2.class;
t reflection2 = classType.newInstance();
Constructor<?> constructor = classType.getConstructor(new Class[] {});
reflection2 = constructor.newInstance(new Object[] {});

        Class<?> classType = Reflection2.class;
// Object reflection2 = classType.newInstance();
        Constructor<?> constructor = classType.getConstructor(new Class[] {});
 	Object reflection2 = constructor.newInstance(new Object[] {});

情况二:现在是有参构造函数，那我们只有一种方法来通过反射生成对象:

[java] view plain copy print ?

Class<?> tClass = Person.class;
Constructor cons = classType.getConstructor(new Class[]{String.class, int.class});
Object obj = cons.newInstance(new Object[]{“zhangsan”, 19});

Class<?> tClass = Person.class;  
Constructor cons = classType.getConstructor(new Class[]{String.class, int.class});   
Object obj = cons.newInstance(new Object[]{“zhangsan”, 19});

接下来根据以上的一些常用的方法，使用反射举几个例子（使用反射来访问类中的方法）:

[java] view plain copy print ?

package com.jiangqq.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
* 反射练习二,使用反射访问类中的方法
*
* @author jiangqq
*
*/
public class Reflection2 {
public int sum(int a, int b) {
return a + b;
}
public String addStr(String str) {
return "This is the:" + str;
}
public static void main(String[] args) throws Exception {
Class<?> classType = Reflection2.class;
// Object reflection2 = classType.newInstance();
Constructor<?> constructor = classType.getConstructor(new Class[] {});
Object reflection2 = constructor.newInstance(new Object[] {});
// 通过反射进行反射出类中的方法
Method sumMethod = classType.getMethod("sum", new Class[] { int.class,
int.class });
//invoke方法的值永远只是对象
Object result1 = sumMethod.invoke(reflection2, new Object[] { 6, 10 });
System.out.println((Integer) result1);
Method addStrMethod = classType.getMethod("addStr",
new Class[] { String.class });
Object result2 = addStrMethod.invoke(reflection2,
new Object[] { "tom" });
System.out.println((String) result2);
}
}

package com.jiangqq.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
 * 反射练习二,使用反射访问类中的方法
 * 
 * @author jiangqq
 * 
 */
public class Reflection2 {
	public int sum(int a, int b) {
		return a + b;
	}
	public String addStr(String str) {
		return "This is the:" + str;
	}
	public static void main(String[] args) throws Exception {
		Class<?> classType = Reflection2.class;
		// Object reflection2 = classType.newInstance();
		Constructor<?> constructor = classType.getConstructor(new Class[] {});
		Object reflection2 = constructor.newInstance(new Object[] {});
		// 通过反射进行反射出类中的方法
		Method sumMethod = classType.getMethod("sum", new Class[] { int.class,
				int.class });
		//invoke方法的值永远只是对象
		Object result1 = sumMethod.invoke(reflection2, new Object[] { 6, 10 });
		System.out.println((Integer) result1);
		Method addStrMethod = classType.getMethod("addStr",
				new Class[] { String.class });
		Object result2 = addStrMethod.invoke(reflection2,
				new Object[] { "tom" });
		System.out.println((String) result2);
	}
}

④:通过反射机制调用对象的私有方法,访问对象的私有变量....

我们大家都知道，在Java语言中，如果我们对某些变量，或者方法进行private的声明，然后我们在其他类中进行不能去调用这些方法和变量，但是通过反射机制，这些私有声明将不复存在【提醒一点:在写程序的时候，我们最好不要故意经常去使用反射机制来打破这种私有保护...】

要实现这种功能，我们需要用到AccessibleObject类中的public void setAccessible(boolean flag)方法:

使用这个方法，把参数flag设置成true，然后我们的field或者method就可以绕过Java语言的语法访问的检查

具体使用如下:

<a>使用反射去访问私有方法

[java] view plain copy print ?

package com.jiangqq.reflection;
public class Test01 {
private String getName(String name) {
return "This i:" + name;
}
}
package com.jiangqq.reflection;
import java.lang.reflect.Method;
public class TestPrivate01 {
public static void main(String[] args) throws Exception {
Test01 p = new Test01();
Class<?> classType = p.getClass();
Method method = classType.getDeclaredMethod("getName",
new Class[] { String.class });
method.setAccessible(true);
Object object = method.invoke(p, new Object[] { "tom" });
System.out.println((String)object);
}
}

package com.jiangqq.reflection;
public class Test01 {
	private String getName(String name) {
		return "This i:" + name;
	}
}


package com.jiangqq.reflection;
import java.lang.reflect.Method;
public class TestPrivate01 {
	public static void main(String[] args) throws Exception {
		Test01 p = new Test01();
		Class<?> classType = p.getClass();
		Method method = classType.getDeclaredMethod("getName",
				new Class[] { String.class });
		method.setAccessible(true);
		Object object = method.invoke(p, new Object[] { "tom" });
		System.out.println((String)object);
	}
}

<b>使用反射机制去访问私有变量:

[java] view plain copy print ?

package com.jiangqq.reflection;
public class Test02 {
private String name="张三";
private String getName()
{
return name;
}
}
package com.jiangqq.reflection;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestPrivate02 {
public static void main(String[] args) throws Exception {
Test02 p = new Test02();
Class<?> classType = p.getClass();
Field field = classType.getDeclaredField("name");
//设置true,使用可以绕过Java语言规范的检查
field.setAccessible(true);
//对变量进行设置值
field.set(p, "李四");
Method method = classType.getDeclaredMethod("getName", new Class[] {});
method.setAccessible(true);
Object object = method.invoke(p, new Object[] {});
System.out.println((String) object);
}
}

Hollivan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中反射机制（Reflection）学习

首先看下基本概念:(一)在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。Java 反射机制主要提供了以下功能:①:在运行时判断任意一个对象所属的类。②:在运行时构造任意一个类的对象。 ③:在运行
复制链接

扫一扫

专栏目录