反射
反射的基石---》Class类
什么是Class
Java程序中的各个Java类同属于一类事物，描述这类事物的Java类名就是Class
class是关键字，定义类用的。Class是一个类名。
举例理解：
对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
人--------->Person
java类---->Class
对比提问：Person类代表人，它的实例对象就是张三、李四这样一个个具体的人。Class类代表Java类，它的各个实例对象又分别对应什么呢？
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？
如何得到各个字节码对应的实例对象(Class类型)，以下列出三种方式
⑴．类名.Class，例如System.class
⑵．对象.getClass(),例如new Date().getClass();
⑶．Class.forName(“类名”);例如Class.forName(“java.util.Date”);做反射的时候主要用这种，因为在写原程序的时候还不知道类的名字，在运行的时候，传递过来一个字符串，这个字符串中包涵了一个类的名字，
Class的作用
Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中的各个Java类，他们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要注意与class关键字的区别。Class类描述了哪些方面信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表，等等。学习反射首先要明白Class这个类
Person p1 = new Person();
字节码：当在原程序中用到Person这个类的时候，首先要从硬盘上把这个类那些二进制代码的类编译成Class放在硬盘上以后就是一堆二进制代码，要把这些二进制代码加载到内存中来，然后才能创建对象。首先把类的字节码加载到内存中，在用这个字节码去赋值出对象来。例如程序中用到了Person和Date和Math这三个类，那么内存中就加载了这三份字节码。每一份字节码就是一个Class的实例对象。例如Classcls = Person.class;这个就代表Person这个类的字节码。p1.getClass();得到属于Person的那份字节码，返回Person类。Class.forName(“java.lang.String”);返回字节码而返回字节码的方式有两种第一种是说这份字节码在曾经被加载过，已经待在JAVA虚拟机中了，直接返回，还有一种就是JAVA虚拟机里面还没有这份字节码，则用类加载器去加载，把加载进来的字节码缓冲在虚拟中，以后要得到这份字节码就不用加载了
给Class类型的变量赋值。Class clsc1 = new Class();这种方法是错误的。Class cls1是代表内存中的一份字节码。
Class cls1 = Date.class//字节码;
ReflectTest.java
/*
isPrimetive();isArray();
*/
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
Stringstr = "abc";
Classcls1 = str.getClass();
Classcls2 = String.class;
Classcls3 = Class.forName("java.lang.String");
System.out.println(cls1== cls2);//都是一份字节码
System.out.println(cls1== cls3);
//是否是基本类型的字节码结果false因为String是类
System.out.println(cls1.isPrimitive());
System.out.println(int.class.isPrimitive());
System.out.println(int.class==Integer.class);
//Integer.TYPE代表它所包装的基本类型的那份字节码结果为true
System.out.println(int.class==Integer.TYPE);
//数组类型不是原始类型
System.out.println(int[].class.isPrimitive());
//是数组类型的
System.out.println(int[].class.isArray());
//总之，只要是在原程序中出现的类型，都有各自的Class实例对象，例如，int[],void...
}
}
理解反射的概念
反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示JAVA类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，他们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这就是学习和应用反射的要点。
Constructor类
得到某个类所有的构造方法：
例子：Constructor[]constructors = Class.forName(“java.lang.String”).getConstructors();
得到某一个构造方法：
例子：
Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时需要用到的类型
创建实例对象
通常方式：Stringstr = new String(new StringBuffer(“abc”));
反射方式：Stringstr = (String)constructor.newInstance(new StringBuffer(“abc”));
//调用获得的方法要用到上面相同类型的实例对象
Class.newInstance()方法
例子：String obj= (String)Class.forName(“java.lang.String”).newInstance();
该方法内部先的到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎么写的？也能够到了缓存机制来保存默认构造方法的实例对象。
反射会导致程序性能严重下降
//获取String类中的构造方法
String.class.getConstructor();
//获取String类中含有两个参数的构造方法
String.class.getConstructor(StringBuffer.class,int.class);
//用一个StringBuffer对象传给String构造方法，然后new出一个Stringd对象
//newString(new StringBuffer("abc"));编译时期就知道类型
//用反射的方法实现以上代码程序运行的时候才知道类型
//StringBuffer.class表示选择哪个构造方法
Constructorconstructor1 = String.class.getConstructor(StringBuffer.class);
//这个StringBuffer表示用的时候传个对象进去
Stringstr2 = (String)constructor1.newInstance(new StringBuffer("abc"));
成员变量的反射：Field类
Field类代表某个类中的一个成员变量
演示用eclipse自动生成Java类的构造方法
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX代表的是x的定义，而不是具体的X变量。
演示代码：
ReflectPoint.java
public class ReflectPoint {
privateint x;
publicint y;
publicReflectPoint(int x, int y) {
super();
this.x= x;
this.y= y;
}
}
ReflectTest.java
import java.lang.reflect.Field;
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
ReflectPointpt1 = new ReflectPoint(3, 5);
//得到一个字段，fieldY不代表具体的值，只代表一个变量，不代表变量中某个对象具体的值
FieldfieldY = pt1.getClass().getField("y");//fieldY的值是多少？是5.错
//表示fieldY在pt1对象上的值
System.out.println(fieldY.get(pt1));
//叫做暴力反射
//获取private的字段需要用getDeclaredField();
FieldfieldX = pt1.getClass().getDeclaredField("x");
//设置可以访问
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
}
}
成员变量反射的综合案例：
将任意一个对象中的所有String类型的成员变量所对应的字符串内容中”b”改成”a”。
ReflectPoint.java
public class ReflectPoint {
publicString str1 = "ball";
publicString str2 = "basketball";
publicString str3 = "itcast";
@Override
publicString toString(){
returnstr1 + ":" + str2+":"+str3;
}
}
ReflectTest.java
import java.lang.reflect.Field;
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
changeStringValue(pt1);
System.out.println(pt1);
}
privatestatic void changeStringValue(Object obj)throws Exception {
//得到字段
Field[]fields = obj.getClass().getFields();
//对字段进行迭代
for(Fieldfield : fields){
//获取字节的类型比较字节码都用==比较
if(field.getType()== String.class){
StringoldValue = (String)field.get(obj);
StringnewValue = oldValue.replace('b','a');
field.set(obj,newValue);
}
}
}
}
成员方法的反射Method类
Method类代表某个类中的一个成员方法
得到类中的某一个方法：
例子：MethodcharAt = 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(Objectobj,Object...args)
JDK1.4:public Object invoke(Objectobj,Object[] args),即按jdk1.4的语法，调用方法中的一个参数，所以，调用charAt方法的代码也可以用jdk1.4改写为
charAt.invoke(“str”,new Object[]{1})形式;
代码演示：
ReflectTest.java
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
//用反射的方式得到字节码中的方法，再用这个方法作用于某个对象
Stringstr2 = "abc";
//调用String中的charAt(1);方法
MethodmethodCharAt = String.class.getMethod("charAt", int.class);
//methodCharAt方法的invoke调用输出结果：c。invoke:表示方法对象身上的方法
System.out.println(methodCharAt.invoke(str2,2));
}
}
对接受数组参数的成员方法进行反射
用反射的方式执某个对象中的main方法
写一个程序，这个程序能够根据用户提供的类名去执行该类中的main方法行。
问题：
启动Java程序的main方法的参数是一个字符串数组，即public static voidmain(String[] args),
通过反射方式来调用main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？JDK1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成若干个单独的参数。所以，在给main方法传递参数时，不能使用代码
mainMethod.invoke(null,new String[]{“xxx”}),javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
解决办法：
mainMethod.invoke(null,new Object[]{newString[]{“xxx”}});
mainMethod.invoke(null,(Object)newString[]{“xxx”});编译器会做特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。
代码演示：
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
//传统方式调用其他类中的main方法
//TestArguments.main(newString[]{"11","22","33"});
//用反射的方式调用其他类中的main方法
//因为我们并不知道TestArguments这个类的名字
//即将要启动的class名字
StringstartingClassName = args[0];
MethodmainMethod = Class.forName(startingClassName).getMethod("main",String[].class);
//调用main方法,因为方法是静态的，所以参数可是null
mainMethod.invoke(null,new Object[]{new String[]{"11","22","33"}});
mainMethod.invoke(null,(Object)new String[]{"11","22","33"});
}
}
//被用于调用main方法的类
class TestArguments{
publicstatic void main(String[] args) {
for(Stringarg : args){
System.out.println(arg);
}
}
}
数组与Object的关系及其反射类型
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class.
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用，非基本类型的一维数组，既可以当作Object类型使用，又可以当作Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作。
代码示例：
ReflectTest.java
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
int[]a1 = new int[]{1,2,3};
int[]a2 = new int[4];
int[][]a3 = new int[2][3];//有一个数组里面装的还是数组(Object)
String[]a4 = new String[]{"a","b","c"};//有一个数组里面装的是String
//都是一维数组，即维数相同，所以字节码相同
System.out.println(a1.getClass()== a2.getClass());
System.out.println(a1.getClass().getName());//[I
//字节码的父类
System.out.println(a1.getClass().getSuperclass());//classjava.lang.Object
//父类-->子类
ObjectaObj1 = a1;
ObjectbObj2 = a4;
//Object[]bObj3 = a1;错误的，有一个数组里面装的是int类型的，基本类型的数组是不能转换成Object数组的
Object[]aObj4 = a3;//正确的，因为数组中装的是String对象
Object[]aObj5 = a4;//正确的，因为数组中装的是数组
System.out.println(a1);//输出对象
System.out.println(a4);
//Arrays.asList方法处理int[]和String[]时的差异。asList是将数组转换成List
System.out.println(Arrays.asList(a1));//[[I@19189e1]
System.out.println(Arrays.asList(a4));//[a,b, c]
}
}
数组的反射应用
演示代码：
ReflectTest.java
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
publicstatic void main(String[] args)throws Exception {
int[]a1 = new int[]{1,2,3};
Objectobj=null;
printObject(a1);
}
//给一个Object就把它打印出来
privatestatic void printObject(Object obj) {
Classclazz = obj.getClass();
//假如是数组,就取出每一个元素
if(clazz.isArray()){
intlen = Array.getLength(obj);//获取数组的长度
for(inti=0;i<len;i++){
System.out.println(Array.get(obj,i));
}
}else{
System.out.println(obj);
}
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
