黑马程序员—JAVA基础—反射

最新推荐文章于 2024-03-15 21:05:26 发布

丢物线

最新推荐文章于 2024-03-15 21:05:26 发布

阅读量392

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/lmxfxm/article/details/47297639

本文深入探讨Java反射机制的概念、基础、应用实例，包括Class类的使用、Constructor、Field、Method类的操作，以及数组中的反射特性。通过具体代码示例，展示了如何利用反射进行类的动态操作，如获取类信息、创建实例、访问成员等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

反射：

一、概念： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调

用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

二、反射的基础：Class类

1、Class类是java.lang包中的一个类，将编译后的java源文件，也就是硬盘中的字节码文件封住起来，提供访问各个成分的方法

2、Class类没有构造函数，可以通过以下三种形式获取示例对象

类名.class

对象.getClass()

Class.forName("类名")

Class.forName的特点：当内存中已经有这个类的字节码对象的，就直接拿来用，如果没有，进进行编译后得到

代码示例

class ClassDemo 
{
	public static void main(String[] args)throws ClassNotFoundException 
	{
		//Person对象
		Person p = new Person();
		Class cla1 = Person.class;
		Class cla2 = p.getClass();
		Class cla3 = Class.forName("Person");//这句代码会抛出异常，因为在输入参数的时候，可能会输错

		System.out.println(cla1 == cla2);//结果为true
		System.out.println(cla2 == cla3);//结果为true
	}
}
class Person//Person类
{

}

从以上的小程序可以得到，三种方式获取的字节码都是同一个字节码对象，也就是编译后的Person.class文件

3、九个预定义Class示例对象（包括8种基本数据类型和void）

4、Class类中一些常用的方法

boolean isPrimitive():
判定指定的 Class 对象是否表示一个基本类型。
boolean isArray()：
判定此 Class 对象是否表示一个数组类。
T newInstance()：
创建此 Class 对象所表示的类的一个新实例
Class<? super T> getSuperclass()：
返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
Package getPackage()：
获取此类的包
String getName()：
以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称
Method getMethod(String name, Class<?>... parameterTypes)：
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Field getField(String name)：
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。

Field getDeclaredField(String name):

返回一个 Field 对象，只要是类中声明的变量都可以访问。
Field[] getFields()：
返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
Constructor<T> getConstructor(Class<?>... parameterTypes)：
返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法

代码示例：

class ClassDemo2 
{
	public static void main(String[] args) 
	{
		Person p = new Person("zhangsan",25);
		String s = "abc";
		System.out.println("String:"+s.getClass().isPrimitive());//false
		System.out.println("int:"+int.class.isPrimitive());//true
		System.out.println("Person:"+p.getClass().isPrimitive());//false
		System.out.println(int.class == Integer.class);//false
		System.out.println(int.class == Integer.TYPE);//true  基本数据类型包装类.TYPE就代表基本数据类型
		System.out.println("isArray:"+int[].class.isArray());//true

		Class cla = p.getClass();
		System.out.println(cla.getPackage());//null
		System.out.println(cla.getName());//Person
		System.out.println(cla.getSuperclass());//class java.lang.Object
	}
}
class Person
{

}

三、Constructor类：内部封住java类中的构造方法，可以通过 getConstructor方法获取

重要方法：newInstance(Object... initargs),通过获得的构造方法来新建示例对象

在Class类中也有newInstance的方法，这个方式是通过某个类空参数的构造方法创建实例

四、Field类：内部封装了java类中的成员变量，代表的是字节码中的变量，而不是对象中的变量，可以通过 getField方法获取

重要方法：setAccessible()，可以见类中私有的成员设置为可见，并且可以直接访问，是继承java.lang.reflect.AccessibleObject的方法

五、Method类：内部封装了java类中的成员函数，可以通过getMethod方法获取

重要方法：Object invoke(Object obj, Object... args)，调用方法，当第一个参数传入null时，说明该方法是静态的。

代码示例：

import java.lang.reflect.*;
class ReflectDemo
{
	public static void main(String[] args)throws Exception 
	{
		//String类中有构造方法String(StringBuffer buffer)
		//String s = new String(new StringBuffer("abc"));
		Constructor cs = String.class.getConstructor(StringBuffer.class);//抛出NoSuchMethodException异常
		String s = (String)cs.newInstance(new StringBuffer("abc"));//抛出InstantiationException异常
		System.out.println(s);
		
		Person p = new Person("zhangsan",25);
		Class cla = p.getClass();
		Field name = cla.getField("name");
		System.out.println(name);//public java.lang.String Person.name，因为是字节码中的变量，所以没有值
		System.out.println(name.get(p));//zhangsan，这时p对象中的值
		//Field f2 = p.getClass().getField("age");
		//出现java.lang.NoSuchFieldException: age，说明私有不能获取

		//getDeclaredField，只要是类中声明的变量都可以访问
		Field age = cla.getDeclaredField("age");
		/*
		System.out.println(age.get(p));
		虽然可以获取成员变量，但是还不能进行访问，因为是私有的
		Exception in thread "main" java.lang.IllegalAccessException: Class ReflectDemo c
		an not access a member of class Person with modifiers "private"
		*/
		//setAccessible方法将成员设置为可见，并且可以直接访问,称为暴力反射
		age.setAccessible(true);
		System.out.println(age.get(p));//25

		//通过getMethod获取方法，第一个参数为方法名，第二个参数为可变参数，为要获取的方法中的参数
		Method m1 = cla.getMethod("method",String.class);
		//调用invoke方法，运行该方法，第一个参数为类的示例对象，第二个参数为传入该方法的实际参数
		m1.invoke(p,"abc");
	}
}
class Person 
{
	public String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public void method(String s)
	{
		System.out.println(s);
	}
}

练习1：将一个类中的String类型的成员变量中的a改为b

import java.lang.reflect.*;
class ReflectTest 
{
	public static void main(String[] args)throws Exception 
	{
		Test t = new Test();
		System.out.println("替换前"+t.str1+"..."+t.str2);
		Class cla = t.getClass();
		Field[] fields = cla.getFields();//将类中的所有成员取出并存到Field类型的数组中
		for(Field f:fields)//增强for循环
		{
			//字节码对象是唯一的，所有用==比较就可以了，不需要写equals
			if(f.getType() == String.class)//获取Field的类型并进行比较
			{
				String oldValue = (String)f.get(t);
				String newValue = oldValue.replace('a','b');//Stirng类中的replace方法
				f.set(t,newValue);//通过set方法给对象中的成员重新赋值
			}
		}
		System.out.println("替换后"+t.str1+"..."+t.str2);
	}
}
class Test
{
	public String str1 = "aabb";
	public String str2 = "cccc";
}

练习2：用反射的方式执行某个类中的main方法

import java.lang.reflect.*;
class ReflectTest2 
{
	public static void main(String[] args)throws Exception 
	{
		Test t = new Test();
		Class cla = t.getClass();
		Method m = cla.getMethod("main",String[].class);
		/*
		m.invoke(null,new String[]{"zhangsan","lisi","wangwu"});
		这种方式会编译失败，因为在jdk1.5中一个数组视为一个参数，但是在jdk1.5之前，会将数组
		拆开变为多个参数，高版本兼容低版本，所以编译时会按照低版本编译，就不符合主函数的参数
		new Object[]{new String[]{"zhangsan","lisi","wangwu"}}的意思的是String类型的数组是
		Object数组中的一个元素
		(Object)new String[]{"zhangsan","lisi","wangwu"}的意思是将String类型数组强转为一个
		Object类型，可作为一个参数进行传递
		*/
		//m.invoke(null,new Object[]{new String[]{"zhangsan","lisi","wangwu"}});
		m.invoke(null,(Object)new String[]{"zhangsan","lisi","wangwu"});
	}
}
class Test 
{
	public static void main(String[] args) 
	{
		for(String s:args)
		{
			System.out.println(s);
		}
	}
}

六、数组中的反射：

1、具有相同类型和相同微维度的数组视为同一个类型，也就是对应相同的Class对象
2、基本数据类型的一维数组可以当作Object类型使用，不能当作Object[]类型使用
非基本数据类型的一维数组，可以当作两者使用

代码示例：

import java.util.*;
class ArrayReflect 
{
/*
1、具有相同类型和相同微维度的数组视为同一个类型，也就是对应相同的Class对象
2、基本数据类型的一维数组可以当作Object类型使用，不能当作Object[]类型使用
   非基本数据类型的一维数组，可以当作两者使用
*/
	public static void main(String[] args) 
	{
		int[] arr1 = new int[]{1,4,7};
		String[] arr2 = new String[]{"zhangsan","lisi","wangwu"};

		//第二点体现在Arrays类中iasLst方法将数组转成集合的时候
		//如果是基本数据类型数组，则视为一个参数，相当于一个数组对象
		//但是String类型的数组可以当作Object[]参数来传递
		System.out.println(Arrays.asList(arr1));//[[I@659e0bfd]
		System.out.println(Arrays.asList(arr2));//[zhangsan, lisi, wangwu]
	}
}