——反射

关注

原创最新推荐文章于 2026-04-01 03:36:35 发布 654 阅读 AI 写同款· GEO 优化 ›

UE4-（反射）反射采集一、现在有两个反射采集形状：球体和盒体通常将屏幕空间反射和反射捕获相结合，两者各有优缺点，结合使用是希望同个结合两者的优点来弥补缺点。大多情况下使用球体反射采集：效果：不管怎么移动相机位置，屏幕上都会有反射效果。问题：当反射采集与屏幕空间反射过渡时，反射画面中的物体位置会发生变化。原因：当屏幕空间反射过渡到反射捕获，引擎会切换使用两者，但是屏幕空间反射的优先级始终更高。解释：反射采集会采集一张360度的瞬时图像，用于反射效果。图像中的物体位置与屏幕空间反射出来的物体位阅读详情

写在前面的话：今天把张孝祥老师的关于反射的部分看完了，首先敬老师传授给我知识！谢谢老师深入、生动、透彻的讲解，好了闲言少叙，反射提高了java程序的灵活性，尤其是在框架开发中的应用，通过一个对象引用我们可以获取这个类的构造方法、方法、成员（包括私有成员）。

反射：就是把java类的各种成分映射成相应的类。

第一讲反射的基石——》Class类

Class 类：众多的java类属于同一事物，描述这类事物的java类名就是Class、
比如众多的人用一个Person类来表示，众多的java类用Class表示

每一个类在内存中都会有一份字节码，每一份字节码就是一个Class类的实例对象。
例如：Person p1 = new Person();
Person p2 = new Person();
Date d = new Date();

对Class实例化：Class cls1 = Date.class;//字节码
Class cls2 = Person.class;

1. 对象.getClass();
p1.getClass();//获取p1对应的字节码

2. Class.forName("类包");
Class.forName("java.lang.String");
forName();的作用：1，返回已加载类的字节码。2，对于还未加载到java虚拟机中的类，用类加载器去加载，把加载的字节码放到缓存区然后返回。

3. 类名.class,

例如System.class.

九个预定义的Class对象中，包括八个基本类型加一个void
int .class == Integer.TYPE

数组类型的Class实例对象，用Class.isArray();来判断是不是数组类型的；

总之，只要在源程序中出现的类型，都有各自的Class实例对象

第二讲理解反射的概念 (类中的方法可以映射成反射中的Method类)

反射就是把java类的各种成分（包构造方法方法成员变量）映射成相应的java类

例如System中有：System.exit、System.getProperties，System中的这些方法都可以用一个类Method来表示，
方法对象指向具体的方法
Method——》methodobj1——》exit
Method——》methodobj2——》getProperties

第三讲构造方法的反射应用 (类中的一个构造方法可以映射成放射中的Constructor类)

Constructor类代表某个类中的一个构造方法。

1.得到某个类的所有构造方法。
Constructor[] constructors = Class.forName("java.lang.String").getConstructors();

2.得到某一个构造方法，
Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

3.创建实例对象，
通常方式：String str = new String(new StringBuffer("abc"));
反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));
调用获得的方法，要用到上面相同类型(String)的实例对象，

4. Class.newInstance();获取不带参数的构造方法，然后用该方法创建实例对象，

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

第四讲成员变量的反射

1.Field类：代表某个类中的一个成员变量。

2.演示反射获取成员变量的方法

获取公有的方法：
ReflectPoint pt1 = new ReflectPoint(3, 5);
Field fieldY = pt1.getClass().getField("y");
此时的fieldY还没有具体值，代表了一个变量。下面取出pt1下的y的具体值
//fieldY不是对象上的变量，而是类的变量，要用它去取对象上的对应的值。
System.out.println(fieldY.get(pt1));

获取私有成员变量的方法：暴力反射，获取类中的私有成员的方法。

Step1.使定义的成员（无论公有还是私有）处于可见
Field fieldX = pt1.getClass().getDeclaredField("x");

Step2.使成员处于可被取状态
fieldX.setAccessible(true);

Step3.取出并打印。
System.out.println(fieldX.get(pt1));

第五讲成员变量反射的综合案例

1.代码演示。将所有成员变量的某个字母修改。

/*
* 步骤：
* 1.得到所有的字段
* 2.扫描字段，找出String类型的字段。
* 3.修改String类型字段的值,并保存
* */
代码:
private static void changeStringValue(Object obj)throws Exception {

//step 1获取对象obj中的所有成员
Field[] fields = obj.getClass().getFields();

//step 2 对获取到的成员进行遍历，并判断是否是某一类型（String类型）

//根据字节码是否相等来进行判断是不是同一类型成员。
for(Field field : fields)
{
//判断字节码相等用==号，而不用equals.
//if(field.getType().equals(String.class)))
if(field.getType()==String.class)
{
//step 3 对String类型的成员进行获取值的获取，并替换保存。
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}

}

第六讲成员方法的反射

Method类:代表某个类中的一个成员方法。（Constructor代表构造方法）

1.得到类中的某个方法。
Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);

2.调用方法。
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str,1));

注意：如果传递给Method对象的invoke()方法的第一个参数为null,这就说明
该Method对象对应的是一个静态方法。

实例：获取charAt()方法，并进行调用。
//str1.charAt(1);
用反射的方式得到这个字节码上的方法。在用该方法作用于某个对象，在这里作用于对象str1。
Method methodCharAt = String.class.getMethod("charAt", int.class);

调用获取的方法，并打印
System.out.println(methodCharAt.invoke(str1, 1));

//调用方式jdk1.4
System.out.println(methodCharAt.invoke(str1, new Object[] {2}));

第七讲对接收数组参数的成员方法进行反射

1.根据用户提供的类名（类中有静态代码）调用该类中的main方法。
//调用主函数的main方法语句。
TestArguments.main(new String[]{"hehe","123"});

//定义用户类
class TestArguments{
//定义一个静态方法，调用主函数的main方法
public static void main(String[] args){
for(String arg : args)
{
System.out.println(arg);
}
}

2.用反射调用主函数的main方法
如何给invoke方法传递参数呢？
按照jdk1.4的语法，数组中的每一个元素对应一个参数，jdk1.5兼容了1.4版本，
当把数组传递给invoke方法时，javac会把数组打散成若干个单独的参数。所以有
以下两种解决办法
解决方法：
1.给要传递的数组添加一个包装，即使打散后还是一个整体的数组
mainMethod.invoke(null, new Object[]{new String[]{"hehe","123"}});
2.将这个数组封装成一个对象，告诉javac，不可以拆
mainMethod.invoke(null, (Object)new String[]{"hehe","123"});

第八讲数组与Object的关系及其反射类型

1.具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

int [] a1 = new int[3];
int [] a2 = new int[4];
int [][] a3 = new int[2][3];
String [] a4 = new String[3];

System.out.println(a1.getClass() == a2.getClass());//字节码相等

2.基本类型的一维数组可以被当做Object类型使用，不可以被当做Object[]类型使用。
非基本类型的一维数组，既可以又可以你懂得

3.Arrays.asList()方法在处理int[]和String[]时的差异。

第九讲数组的反射应用

1.Array工具类完成对数组的反射操作。
//数组反射应用（主函数中的语句）
Object obj = null;
printObject(a4);
printObject("xyz");

private static void printObject(Object obj)
{
//获取传进来的对象的内容。
Class clazz = obj.getClass();
//判断是不是一个数组
if(clazz.isArray())
{
//获取数组长度并遍历打印
int len = Array.getLength(obj);
for(int i=0;i<len;i++)
{
System.out.println(Array.get(obj, i));
}
}
else
{
//不是数组就直接打印
System.out.println(obj);
}
}

代码实例：这是第一讲到第九讲所有的代码具体实现。

package Reflect;

public class ReflectPoint {

<span style="white-space:pre">	</span>//定义两个成员公有和私有
	private int x;
	public int y;
	//定义String类型成员
	public String str1 = "ball";
	public String str2 = "basketball";
	public String str3 = "itcast";
	//通过构造方法给x和y赋值，创建构造函数（快捷键）
	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ReflectPoint other = (ReflectPoint) obj;
		if (x != other.x)
			return false;
		if (y != other.y)
			return false;
		return true;
	}

	@Override

<span style="white-space:pre">	</span>//复写toString方法
	public String toString(){
		return str1+"****"+str2+"******"+str3;
	}
	
}

代码实例：

<pre name="code" class="java">package Reflect;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class reflectTest1 {

	public static void main(String[] args)throws Exception {
		String str1 = "abc";
		/*
		 * 三种方法获取字节码
		 * */
		Class cls1 = str1.getClass();
		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1==cls2);
		System.out.println(cls1==cls3);

		System.out.println(cls1.isPrimitive());//是否是基本类型，false
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class==Integer.class);//基本类型跟包装类
		System.out.println(int.class==Integer.TYPE);//定义了一个基本类型的变量
		System.out.println(int[].class.isPrimitive());//定义了一个数组，不是基本类型
		System.out.println(int[].class.isArray());//判断是不是数组
		
		
		//new String(new StringBuffer("abc"));
		//第一个StringBuffer表示选择哪个构造方法，第二个用来传参数进去
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
		System.out.println(str2.charAt(2));

<span style="white-space:pre">		</span>//获取公有成员
		ReflectPoint pt1 = new ReflectPoint(3, 5);
		Field fieldY = pt1.getClass().getField("y");
		//此时的fieldY还没有具体值，代表了一个变量。下面取出pt1下的y的具体值
		//fieldY不是对象上的变量，而是类的变量，要用它去取对象上的对应的值。
		System.out.println(fieldY.get(pt1));
		
		
		//暴力反射，获取类中的私有成员的方法。 
		Field fieldX = pt1.getClass().getDeclaredField("x");
		fieldX.setAccessible(true);
		System.out.println(fieldX.get(pt1));

<span style="white-space:pre">		</span>//改变String类型成员变量的值		
		changeStringValue(pt1);
		System.out.println(pt1);
		
		//str1.charAt(1);
		//用反射的方式得到这个字节码上的方法。在用该方法作用于某个对象，
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1));
		//JDK1.4版本的调用方法
		System.out.println(methodCharAt.invoke(str1, new Object[] {2}));
		
		//静态代码调用main方法。
		TestArguments.main(new String[]{"hehe","123"});
		
		//用反射调用main方法。
		/*String startingClassName = args[0];
		Method mainMethod = Class.forName(startingClassName).getMethod("mian", String[].class);
		//mainMethod.invoke(null, new Object[]{new String[]{"hehe","123"}});
		mainMethod.invoke(null, (Object)new String[]{"hehe","123"});*/
		
		
		int [] a1 = new int[]{1,2,3};
		int [] a2 = new int[4];
		int [][] a3 = new int[2][3];
		String [] a4 = new String[]{"a","b","c"};
		
		//维数相同的基本类型数组，判断其字节码是否相同。

<span style="white-space:pre">		</span>System.out.println(a1.getClass() == a2.getClass());
		//System.out.println(a1.getClass() == a3.getClass());
		//System.out.println(a1.getClass() == a4.getClass());
		System.out.println(a1.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		
		
		//数组反射应用
		Object obj = null;
		printObject(a4);
		printObject("xyz");
	}

	private static void printObject(Object obj) {

<span style="white-space:pre">		</span>//获取传进来的对象的内容。
		Class clazz = obj.getClass();

<span style="white-space:pre">		//判断是不是一个数组</span>
		if(clazz.isArray())
		{

<span style="white-space:pre">			//获取数组长度并遍历打印</span>
			int len = Array.getLength(obj);
			for(int i=0;i<len;i++)
			{
				System.out.println(Array.get(obj, i));
			}
		}
		else
		{
			System.out.println(obj);
		}
	}

	private static void changeStringValue(Object obj)throws Exception {
		//扫描类的对象中所有String类型的变量
		/*
		 * 步骤：
		 * 1.得到所有的字段
		 * 2.扫描字段，找出String类型的字段。
		 * 3.修改String类型字段的值,并保存
		 * */
		//step 1 得到所有的字段
		Field[] fields = obj.getClass().getFields();
		
		//step 2 扫描字段，找出String类型的字段
		for(Field field : fields)
		{
			//判断字节码相等用==号
			//if(field.getType().equals(String.class)))
			if(field.getType()==String.class)
			{
				//step 3 修改String类型字段的值,并保存
				String oldValue = (String)field.get(obj);
				String newValue = oldValue.replace('b', 'a');
				field.set(obj, newValue);
			}
		}
		
	}
}

class TestArguments{
	//定义一个静态方法，调用主函数的main方法
	public static void main(String[] args)throws Exception{
		for(String arg : args)
		{
			System.out.println(arg);
		}
	}
}

第十讲 ArrayList_HashSet的比较及Hashcode分析1.ArrayList和HashSet的不同ArrayList集合允许重复的元素存在，而HashSet一旦发现要存入的元素跟已有元素的哈希值相同就不进行存入操作。默认的equals方法比较的是哈希值，以下的这种情况中，pt1！=pt3的ReflectPoint pt1 = new ReflectPoint(3, 3);ReflectPoint pt2 = new ReflectPoint(5, 5);ReflectPoint pt3 = new ReflectPoint(3, 3);HashCode方法的作用：可以防止内存泄露。方便查询，根据哈希值。防止重复元素。第十一讲框架的概念及用反射技术开发框架的原理1.框架开发中反射的应用。框架开发中我们往往不知道将来要调用的类的具体名字，我们可以将类名写在配置文件中然后再代码中利用反射技术获取配置文件中的类名，然后实例化即可配置文件信息：className=java.util.HashSet

代码实例：

package Reflect;

import java.io.FileInputStream;
import java.util.Collection;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Properties;

public class ReflectTest2 {

	public static void main(String[] args) throws Exception{
		
		//首先要加载配置文件。
		FileInputStream ips = new FileInputStream("config.properties");
		Properties prop = new Properties();
		prop.load(ips);

<span style="white-space:pre">		</span>//切记关闭资源
		ips.close();

<span style="white-space:pre">		</span>//获取配置文件中的类名并实例化
		String className = prop.getProperty("className");
		Collection collections = (Collection) Class.forName(className).newInstance();
		//此处可以比较HashSet和ArrayList
		Collection collections = new HashSet();
		//Collection collections = new ArrayList();
		
		ReflectPoint pt1 = new ReflectPoint(3, 3);
		ReflectPoint pt2 = new ReflectPoint(5, 5);
		ReflectPoint pt3 = new ReflectPoint(3, 3);
		
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);
		
		
		//内存泄露。
		//pt1.y = 7;
		//collections.remove(pt1);
		
		System.out.println(collections.size());
	}

}

水平有限，不足之处请指教，谢谢