Java的反射技术（Class类，Constructor类，Method类， Field类）

2023-11-15

Java编码时知道类和对象的具体信息，此时直接对类和对象进行操作即可，无需反射如果编码时不知道类或者对象的具体信息，此时应该使用反射来实现

为什么要使用反射

反射就是把Java类中的各种成分映射成一个个的java对象。例如，一个类有：成员变量，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象。

反射技术常见于框架中。
比如类的名称放在XML文件中，属性和属性值放在XML文件中，需要在运行时读取XML文件，动态获取类的信息。
在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息。

反射的作用：创建对象、操作属性、调用方法

如何使用反射

掌握反射技术的要点在于：如何从一个class中反射出各个组成部分。反射出来的对象怎么用。

Class类

Class类：代表一个类，是Java反射机制的起源和入口，用于获取与类相关的各种信息
提供了获取类信息的相关方法（Class类继承自Object类）

Class类是所有类的共同的图纸
每个类有自己的对象，同时每个类也看做是一个对象，有共同的图纸Class,存放类的结构信息，能够通过相应方法取出相应的信息：类的名字、属性、方法、构造方法、父类和接口。

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int，void…
反射就是把Java类中的各种成分映射成一个个的java对象。例如，一个类有：成员变量，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象。

那么，既然反射的作用是创建对象、操作属性、调用方法，要实现以上3个作用，需要用到下面介绍的3个类：Constructor类，Method类， Field类

Constructor类

（1）Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法：
例子：

Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：
例子： //获得方法时要用到类型

 Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

（2）创建实例对象：
通常方式：

String str = new String(new StringBuffer("abc"));

反射方式：

String str = (String)constructor.newInstance(new StringBuffer("abc"));

Class.newInstance()方法：
例子：


String obj = (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

Method类

Method类代表某个类中的一个成员方法
得到类中的某一个方法——
例子：

Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

调用方法——
通常方式：

System.out.println(str.charAt(1));

反射方式：

System.out.println(charAt.invoke(str, 1));

如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object… args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

Field类

Field类代表某个类中的一个成员变量
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。(注意访问权限的问题)
示例代码：

ReflectPoint point = new ReflectPoint(1,7);
	Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
	System.out.println(y.get(point));
	//Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
	Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
	x.setAccessible(true);
	System.out.println(x.get(point));

实例演示

首先，我们自定义一个Person类，它是我们将要进行反射的目标。.
在这个类里面，我们定义了：
1.构造方法
2.实例方法
3.属性

package cn.itcast.reflect;

import java.io.InputStream;
import java.util.List;

public class Person {

	public String name = "yaoer";
	private int password = 123;
	private static int age = 23;

	public Person() {
		System.out.println("person");
	}

	public Person(String name) {
		System.out.println(name);
	}

	public Person(String name, int password) {
		System.out.println(name + ":" + password);
	}

	private Person(List list) {
		System.out.println("list");
	}

	public void aa1() {
		System.out.println("aaa1");
	}

	public void aa1(String name, int password) {
		System.out.println(name + ":" + password);
	}

	public String aa1(String name, int[] password) {
		return new String("adad");
	}

	private void aa1(InputStream in) {
		System.out.println(in);
	}

	public static void aa1(int num) {
		System.out.println(num);
	}

	public static void main(String[] args) {
		System.out.println("main！");
	}
}

反射：类的构造函数，创建类的对象

package cn.itcast.reflect;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

//解剖（反射）类的构造函数 ，创建类的对象
public class Demo2 {

	// 1——反射构造函数：public Person（）
	@Test
	public void test1() throws Exception {

		Class<?> clazz = Class.forName("cn.itcast.reflect.Person");
		Constructor<?> c = clazz.getConstructor(null);

		Person p = (Person) c.newInstance(null);

		System.out.println(p.name);
	}

	// 2——反射构造函数：public Person（String name）
	@Test
	public void test2() throws Exception {

		Class<?> clazz = Class.forName("cn.itcast.reflect.Person");
		Constructor<?> c = clazz.getConstructor(String.class);

		Person p = (Person) c.newInstance("xxxooo");

		System.out.println(p.name);
	}

	// 3——反射构造函数：public Person（String name,int password）
	@Test
	public void test3() throws Exception {

		Class<?> clazz = Class.forName("cn.itcast.reflect.Person");
		Constructor<?> c = clazz.getConstructor(String.class,int.class);

		Person p = (Person) c.newInstance("xxxooo",20);

		System.out.println(p.name);
	}
	
	// 4——反射构造函数：private Person(List list)
		@Test
		public void test4() throws Exception {

			Class<?> clazz = Class.forName("cn.itcast.reflect.Person");
			Constructor<?> c = clazz.getDeclaredConstructor(List.class);

			c.setAccessible(true); //暴力反射
			Person p = (Person) c.newInstance(new ArrayList());

			System.out.println(p.name);
		}
		
		@Test
		public void test5() throws Exception {

			Class<?> clazz = Class.forName("cn.itcast.reflect.Person");
			Person p = (Person) clazz.newInstance();
			
		}
}

反射：类中的方法

/**
 * 
 */
package cn.itcast.reflect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

import org.junit.Test;

/**
 * 反射类中的方法
 *
 */
public class Demo3 {
	// 反射类的方法： public void aa1(){
	@Test
	public void test1() throws Exception {

		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Method method = clazz.getMethod("aa1", null);
		Object obj = clazz.newInstance();
		method.invoke(obj, null);
	}

	// 反射类的方法： public void aa1(String name,int password){
	@Test
	public void test2() throws Exception {

		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Method method = clazz.getMethod("aa1", String.class, int.class);
		Object obj = clazz.newInstance();
		method.invoke(obj, "yaoer", 24);
	}

	// 反射类的方法： public void aa1(String name,int[] password){
	@Test
	public void test3() throws Exception {

		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Method method = clazz.getMethod("aa1", String.class, int[].class);
		int[] a = new int[] { 1, 2, 3 };
		Object obj = clazz.newInstance();
		System.out.println(method.invoke(obj, "yaoer", a));
	}

	// 反射类的方法：private void aa1(InputStream in)
	@Test
	public void test4() throws Exception {

		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Method method = clazz.getDeclaredMethod("aa1", InputStream.class);// private
		method.setAccessible(true);
		Object obj = clazz.newInstance();
		System.out.println(method.invoke(obj, new FileInputStream("c://1.txt")));// 对应目录下需要存在此文件
	}

	// 反射类的方法：public static void aa1(int num) {
	@Test
	public void test5() throws Exception {

		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Object obj = clazz.newInstance();
		Method m = clazz.getMethod("aa1", int.class);
		m.invoke(obj, 23);
	}

	// 反射类的方法： public static void main(){
	@Test
	public void test6() throws Exception {

		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Method method = clazz.getMethod("main", String[].class);
		// method.invoke(null, new Object[] {new String[] {"aa","bb"}});
		method.invoke(null, (Object) new String[] { "aa", "bb" });
	}

}

反射：类中的字段（属性）

/**
 * 
 */
package cn.itcast.reflect;

import java.lang.reflect.Field;

import org.junit.Test;

/**
 * 反射字段
 *
 */
public class Demo5 {

	// 反射字段：public String name = "yaoer";
	@Test
	public void test1() throws Exception {
		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Object obj = clazz.newInstance();
		Field f = clazz.getField("name");
		// 获取字段的值
		Object val = f.get(obj);

		// 获取字段的类型
		Class type = f.getType();

		if (type.equals(String.class)) {
			String sval = (String) val;
			System.out.println(sval);
		}

		// 设置字段的值
		f.set(obj, "zhuzhu");
		System.out.println(f.get(obj));

	}

	// 反射字段：private int password;;
	@Test
	public void test2() throws Exception {
		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Object obj = clazz.newInstance();
		Field f = clazz.getDeclaredField("password");
		f.setAccessible(true);// 改变访问权限

		System.out.println(f.get(obj));

	}

	// 反射字段：private static int age = 23;
	@Test
	public void test3() throws Exception {
		Class clazz = Class.forName("cn.itcast.reflect.Person");
		Object obj = clazz.newInstance();
		Field f = clazz.getDeclaredField("age");
		f.setAccessible(true);// 改变访问权限

		System.out.println(f.get(obj));

	}

}

反射技术优缺点

优点

反射提高了Java程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提高硬编码目标类
反射是其他一些常用语言，如C、C++、Fortran或者Pascal等不具备的
Java反射技术应用领域很广，如软件测试、JavaBean等
许多流行的开源框架例如Struts、Hibernate、Spring在实现过程中都采用了该技术

缺点

性能问题：使用反射基本上是一种解释操作哦，用于字段和方法接入时要远慢于直接代码。因此Java反射机制只要应用在对；灵活性和扩展性要求很高的系统框架上，普通程序不建议使用
使用反射会模糊程序内部逻辑：程序员希望在代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂

参考文章：https://blog.csdn.net/Elias94/article/details/80361035

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)