面向对象就是把具体的事物抽象出来用类表示。在Java程序中的一个个存在的Java类也可以被抽象出来用一个类来表示，Java为这种事物提供了一个类，这个累就是Class类。
- 那么Class类的实例是什么呢？答：Class类的实例就是各种累在内存中的字节码。比如：String,Integer。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class。 - Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。学习反射，首先就要明白Class这个类。
那么如何得到各个字节码对应的实例对象（Class类型的实例）？这里我们当然不能new了，因为Class没有构造方法。那么有如下三种方法可以得到字节码文件的对象：
- 类名.class，例如，System.class。
- 对象.getClass()，例如，new Date().getClass()。
- Class.forName(“类名”)，例如，Class.forName(“java.util.Date”);。
九个预定义Class实例对象（八大原始类型+void）：
boolean, byte, char, short, int, long, float, double
注意：
1、Int.class == Integer.TYPE。
2、数组类型的Class实例对象Class.isArray()为true。
3、反射并不是Java5的新特性。
看下面的例子：
- 那么Class类的实例是什么呢？答：Class类的实例就是各种累在内存中的字节码。比如：String,Integer。
package com.test;
public class ReflectTest {
public static void main(String[] args) throws Exception
{
String str = "abc";
Class clazz1 = String.class;
Class clazz2 = str.getClass();
Class clazz3 = Class.forName("java.lang.String" );
System. out.println(clazz1 == clazz2);
//结果：true
System. out.println(clazz2 == clazz3);
//结果：true
System. out.println(clazz1.isPrimitive());
//结果：false
System. out.println(int.class.isPrimitive());
//结果：true
System. out.println(int.class == Integer. class);
//结果：false
System. out.println(int.class == Integer. TYPE);
//结果：true
System. out.println(int[].class.isPrimitive());
//结果：false
System. out.println(int[].class.isArray());
//结果：true
}
}- 结论：只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…而且类型的Class对象只有一个是唯一的。
理解反射的概念
- 反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
构造方法的反射应用
•Constructor类代表某个类中的一个构造方法。
Constructor对象代表一个构造方法，Constructor对象上会有的方法有：得到方法名字，得到所属于的类，产生实例对象。
•得到某个类所有的构造方法：
例子：
Constructor[] constructors= Class.forName("java.lang.String").getConstructors();•得到某一个构造方法：
例子：
Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
//获得方法时要用到类型注意：
一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class… args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。重点：参数类型用什么方式表示？用Class实例对象。
•创建实例对象：
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();该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
请看下面的程序：
import java.lang.reflect.Constructor;
public class ReflectTest
{
public static void main(String[] args) throws Exception
{
Constructor constructor = String.class.getConstructor(StringBuffer.class);
String str = (String)constructor.newInstance( new StringBuffer("abc" ));
System. out.println(str.charAt(2));
//结果：c
}
}成员变量的反射
•Field类代表某个类中的一个成员变量。
•问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，那关联的是哪个对象呢？所以字段field X 代表的是x的定义，而不是具体的x变量。
示例1：
文件Point.java
package fieldReflect;
public class Point
{
private int x;
public int y;
public Point(int x, int y)
{
super();
this.x = x;
this.y = y;
}
}文件ReflectTest.java
package fieldReflect;
import java.lang.reflect.Field;
public class ReflectTest
{
public static void main(String[] args) throws Exception
{
Point rp = new Point(3, 5);
Field fieldY = rp.getClass().getField("y");
System.out.println(fieldY.get(rp));
// 结果：5
}
}示例2：
ReflectTest.java
package fieldReflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPoint rp = new ReflectPoint(3, 5);
Field fieldX = rp.getClass().getField("x");
System. out.println(fieldX.get(rp));
}
}结果：
Exception in thread "main" java.lang.NoSuchFieldException: x
at java.lang.Class.getField(Class.java:1703)
at fieldReflect.ReflectTest.main(ReflectTest.java:11)注意：
如果类的某个成员变量的修饰符是private，那么直接通过getField方法获取Field类型的对象就会出现如上错误。
示例3：
package fieldReflect;
import java.lang.reflect.Field;
public class ReflectTest
{
public static void main(String[] args) throws Exception
{
Point rp = new Point(3, 5);
Field fieldX = rp.getClass().getDeclaredField("x");
System.out.println(fieldX.get(rp));
}
}结果：
Exception in thread "main" java.lang.IllegalAccessException: Class fieldReflect.ReflectTest can not access a member of class fieldReflect.Point with modifiers "private"
at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
at java.lang.reflect.Field.get(Field.java:390)
at fieldReflect.ReflectTest.main(ReflectTest.java:12)注意：
如果类的某个成员变量的修饰符是private，那么直接通过getDeclaredField方法获取Field类型的对象就会出现如上错误。
解决方案：
ReflectTest.java
package fieldReflect;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPoint rp = new ReflectPoint(3, 5);
Field fieldX = rp.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System. out.println(fieldX.get(rp));//结果 3
}
}注意：
通过称之为暴力反射的方式解决，也就是使用setAccessible(true)使private类型的成员变量也可以被获取值。
成员方法的反射
•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})形式。
示例如下：
import java.lang.reflect.Method;
public class ReflectTest
{
public static void main(String[] args) throws Exception
{
String str = "abc";
Method methodCharAt = String.class.getMethod("charAt" , int.class );
System. out.println(methodCharAt.invoke(str, 1));
//结果：b
System. out.println(methodCharAt.invoke(str, new Object[]{2}));
//结果：c
}
}对接收数组参数的成员方法进行反射
•目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。
•示例：
ReflectTest.java
package com.test;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception {
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod( "main", String[].class);
mainMethod.invoke(null, new String[]{ "111","222","333"}) ;
}
}
class TestArguments{
public static void main(String[] args) {
for(String arg : args){
System. out.println(arg);
}
}
}•问题：
启动Java程序的main方法的参数是一个字符串数组，即public static void main(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[]{new String[]{"xxx"}});方法二：
mainMethod.invoke(null,(Object)new String[]{"xxx"}); //编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。改正：
package queue;
import java.lang.reflect.Method;
public class ReflectTest
{
public static void main(String[] args) throws Exception
{
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod( "main", String[].class);
// mainMethod.invoke(null, (Object)new String[]{ "111","222","333"}) ;
mainMethod.invoke(null, new Object[]{new String[]{ "111","222","333"}}) ;
}
}
class TestArguments
{
public static void main(String[] args)
{
for(String arg : args)
{
System. out.println(arg);
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
