------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 对象所表示的类或接口的指定公共成员字段。
判定指定的 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 对象所表示的类的指定公共构造方法
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[]类型使用
非基本数据类型的一维数组,可以当作两者使用
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]
}
}