----------------- android培训、java培训、期待与您交流！-----------------
反射
首先反射一句话的理解就是：将java类中的各种成份映射为相应的java类。
1在一个class中应当有类，构造方法，属性变量，方法，将这些映射为相应的类Class,Constructor,Method,Field。通过这些类可进行相应的操作。
2一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。
下面来反射的基石----Class类
Class代表众多的Java类，它的各个实例对象代表对应各个类在内存中的字节码。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型各自的Class
而获取字节码对应的实例对象是:
类名.class; File.class;
Class.forName(); Class.forName("java.io.File");
对象.getClass(); new File("abc.txt").getClass();
在java中已经预定义了9个Class实例对象：就是8个基本类型对象和void类型对象。
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…
Class的实例就是字节码，且一个类在虚拟机中通常只有一份字节码：
Date d1 = new Date();
Class clazz1 = d1.getClass();
Class clazz2 = Date.class;
Class clazz3 = null;
clazz3 = Class.forName("java.util.Date");
//验证<span style="white-space: pre;">一个类在虚拟机中通常只有一份字节码</span>
if(clazz1==clazz2)
{
System.out.println(clazz1.getName());<span style="white-space:pre"> </span>
}
if(clazz1==clazz3)
{
System.out.println(clazz1.getName());<span style="white-space:pre"> </span>//发现3个实例都相等
}
Constructor类-------Constructor类代表某个类中的一个构造方法
import java.lang.reflect.Constructor;
public class ClassDemo {
public static void main(String[] args) throws Exception {
// 原始方式：
String str1 =new String("原始方式："+"12345");
System.out.println(str1);
// 反射方式：
// 得到某个类所有的构造方法: --返回一个构造方法的数组
Constructor<?> cons1[] =Class.forName("java.lang.String").getConstructors();
// 得到某一个构造方法: --在getConstructor()指定类
Constructor<?> cons2 = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
// 创建实例对象newInstance();
String str2 =(String)cons2.newInstance(new StringBuffer("反射方式："+"12345"));
System.out.println(str2);
}
}ef: String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。用到了缓存机制来保存默认构造方法的实例对象。
Field类----代表某个类中的一个成员变量
package com.zhy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x, int y) {
this.x = x;
this.y = y;
}
}
public class ClassDemo {
public static void main(String[] args) throws Exception {
FieldDemo();
}
public static void FieldDemo() throws Exception{
// 创建对象
ReflectPoint rfp =new ReflectPoint(10, 20);
// 获取私有变量x--getDeclaredField()
Field fieldX = ReflectPoint.class.getDeclaredField("x");
// 设置x变量可以访问
fieldX.setAccessible(true);
// 这就是访问私有变量方式---称暴力反射
System.out.println(fieldX.get(rfp));
// 访问非私有变量
Field fieldY =ReflectPoint.class.getField("y");
// 打印的fieldY是变量的详细信息
// 在这里是---- public int com.zhy.ReflectPoint.y
System.out.println(fieldY);
System.out.println(fieldY.get(rfp));
}
}
class aaa
{
public String id="abc";
public String name="abd";
aaa(String id,String name){
this.id =id;
this.name=name;
}
}
public class ClassDemo {
public static void main(String[] args) throws Exception {
aaa a =new aaa("abc", "zhangsan");
FieldDemo(a);
}
public static void FieldDemo(Object obj) throws Exception{
// 获取类中所有变量
Field fields []=obj.getClass().getFields();
// 变量变量
for (Field field : fields) {
System.out.println("原值："+field.get(obj));
// 如果变量类型 == String类型
if (field.getType() == java.lang.String.class) {
// 获取变量值并修改
String strnew =(String) field.get(obj);
field.set(obj, strnew.replace("a", "b"));
System.out.println("现在: "+field.get(obj));
}
}
}
｝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对象对应的是一个静态方法！
例子： 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})形式。
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})形式。
package com.zhy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassDemo {
public static void main(String[] args) throws Exception {
MethodDemo();
}
public static void MethodDemo() throws Exception{
Method method[] = String.class.getMethods();
for (Method method2 : method) {
// System.out.println(method2.getName()); //获取方法名称
// 返回描述Method的字符串--即方法的名称,修饰符,返回值,参数
System.out.println(method2.toGenericString());
// System.out.println(method2.toString());
}
// 获取某个方法--根据方法名
Method hashCode =String.class.getMethod("hashCode");
// 调用此方法invoke()--在这里是调用hashCode返回zhy的哈希值
// public Object invoke(Object obj,Object... args)
// 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
// 参数： obj - 从中调用方法的对象，args - 用于方法调用的参数
// 如果是静态方法可以忽略对象，参数为null
System.out.println(hashCode.invoke("zhy"));
}
}
用反射方式执行某个类中的main方法:
启动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"}});
class bbb
{
public static void methodTest(String [] args) throws Exception {
//用反射方式执行某个main方法
//一般方式：
// Test.main(new String[]{"111","222","333"});
// System.out.println("-------");
//反射方式： 执行aaa类中的main方法
String MainClassName = args[0];
Method methodMain =Class.forName(startingClassName).getMethod("main",String[].class);
//强制转换为超类Object
methodMain.invoke(null,(Object)new String[]{"111","222","333"});
}
}
class aaa {
public static void main(String [] args)
{
for(String arg:args)
{
System.out.println("----" + arg);
}
}
}数组的反射：
1 具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
String[] a1 = new String[8];
String[] a2 = new String[9];
System.out.println(a1.getClass() == a2.getClass()); //结果为true
String[] a2 = new String[9];
System.out.println(a1.getClass() == a2.getClass()); //结果为true
2 基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；
非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
3 代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
代码演示：
public class ClassDemo {
public static void main(String[] args) throws Exception {
arraysDemo();
}
public static void arraysDemo() throws Exception{
int [] a1 =new int[5];
int [] a2 =new int[8];
int [][] a3=new int[3][4];
String [] a4=new String[6];
// System.out.println(a1.getClass() == a3.getClass()); 错误
// System.out.println(a1.getClass() == a4.getClass()); 错误
System.out.println(a1.getClass() == a2.getClass());
// getSuperclass()获取父类为Object类对应的Class
System.out.println(a1.getClass().getSuperclass().getName());
System.out.println(a4.getClass().getSuperclass().getName());
// 基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；
// 非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Object o1 =a1;
Object o2=a3;
Object o3=a4;
// Object [] o11 =a1; 错误
Object[] o12=a3;
Object[] o13=a4;
}
｝
反射的作用------实现框架功能
框架索要实现的功能：
1 ef：就好像我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，
把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
2 我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
public ReflectTest{
public static void main(String[] args) throws Exception{
Properties props = new Properties();
//Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件
//InputStream ips = ReflectTest.class.getResourceAsStream("config.properties");
InputStream ips = ReflectTest.class.getResourceAsStream("config.properties");
props.load(ips);
ips.close();
//获取配置文件中的变量--类名
String className = props.getProperty("className");
//获取字节码
Class clazz = Class.forName(className);
//创建集合对象
Collection coll = (Collection)clazz.newInstance();
//分别创建ReflectPoint对象
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
//向集合添加元素
coll.add(pt1);
coll.add(pt2);
coll.add(pt3);
coll.add(pt1);
System.out.println(coll.size());
}
}
696
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
