黑马程序员--反射

最新推荐文章于 2014-06-11 23:46:20 发布

sunyonglei88

最新推荐文章于 2014-06-11 23:46:20 发布

阅读量458

点赞数

分类专栏：黑马程序文章标签： java 黑马程序员反射

本文链接：https://blog.csdn.net/sunyonglei88/article/details/29343775

版权

黑马程序专栏收录该内容

19 篇文章 0 订阅

订阅专栏

------------android培训、java培训、期待与您交流！--------------

大纲：

一、Class类

二、反射的概念

三、构造方法的反射

四、成员变量的反射

五、成员方法的反射

六、通过反射调用main方法

七、数组的反射

八、框架的概念及用反射技术开发框架的原理

一、Class类
Perosn p1 = new Person();
Perosn p2 = new Person();

Class cls1 = Date.class //表示Date的字节码
Class cls2 = Person.class //表示Person的字节码
Class cls3 = Math.class //表示Person的字节码

一个类文件先被类加载器加载到内存中，再用这些字节码复制出一个个实例对象来，

不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间

又可分别用一个个的对象来表示，这些对象然具有相同的类型是Class类型。

同一个类字节码只需加载一次，java虚拟机会把它缓存起来，

下次直接调用就行不需要再次加载。

获取类字节码的三种方法：
1. Person.class;
2. p1.getClass();
3. Class.forName("java...String")(必须指定类的完整名称，最常用，可以在运行之前不需要知道所加载的类）

例子：
String str1 = "abc";
Class cls1 = str1.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
以上用三种方式得到Class对象，得到的cls1, cls2, cls3对象完全相同，返回的都是同一份字节码对象。

特殊的Class对象
1、java有九个预定义Class实例对象（八大原始类型+void）：void也想到于一个返回值
cls1.isPrimitive()可以判断是否是基本类型的字节码
如整型的字节码可表示为：int.class或Integer.TYPE
System.out.println(int.class == Integer.class);结果是false，
因为Integer不是基本类型所以对应的字节码肯定不同。
可以将Integer.class改为Integer.TYPE
System.out.println(int.class == Integer.TYPE); 结果为true

2、数组的Class对象

判断是否是数组类的方法：Class.isArray()
如：System.out.println(int[].class.isArray());

示例：

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…

二、反射的概念

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个

Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等

信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等

也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，

方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示

，它们是Field、Method、Constructor、Package等等。

三、构造方法的反射
Constructor对象代表一个构造方法，Constructor对象上会有的方法有：

得到方法名字，得到所属于的类，产生实例对象。

得到某个类所有的构造方法：
Constructor[] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：
Constructor constructor = Class.forName("java.lang.String")

.getConstructor(StringBuffer.class，int.class);//获得方法时要用到类型

创建实例对象：
a.通常方式：
String str = new String(new StringBuffer("abc"));
b.反射方式：
Constructor constructor = Class.forName(“java.lang.String”).
getConstructor(StringBuffer.class);
String str = (String)constructor.newInstance(new StringBuffer(“abc”));
// 必须进行强转，因为在编译时不知constructor类型，且传入的参数必须与定义构造方法对象时一致。

示例：

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类代表某个类中的一个成员变量。
public class ReflectPoint {
private int x;
public int y ;
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
}

ReflectPoint point = new ReflectPoint(1,7);
//先获取变量y的对象
Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
//传入具体对象参数，获取此对象的具体变量值
System.out.println(y.get(point));//结果是7
Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
//报错，因为x是private变量，对外部是隐藏的。
可以通过暴力反射获取x：
Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
x.setAccessible(true);
System.out.println(x.get(point);

练习：
将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
答案：
ReflectPoint

package demo;

public class ReflectPoint {

	private int x;
	public int y;
	public String str1 = "ball";
	public String str2 = "basketball";
	public String str3 = "itcast";

	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		return str1 + ":" + str2 + ":" + str3;
	}

}

将ReflectPoint对象的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"

package demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ReflectTest {

	public static void main(String[] args) throws Exception {

		ReflectPoint rp = new ReflectPoint(3, 5);
		changeStringValue(rp);
		System.out.println(rp);
	}

	public static void changeStringValue(Object obj) throws Exception {

		Field[] fields = obj.getClass().getFields();
		for (Field field : fields) {
			if (field.getType() == String.class) {
				String oldValue = (String) field.get(obj);
				String newValue = oldValue.replace('b', 'a');
				field.set(obj, newValue);
			}

		}

	}

}

结果：
aall:aasketaall:itcast

五、成员方法的反射
Method类代表某个类中的一个成员方法。
得到类中的某一个方法：
Method charAt = Class.forName("java.lang.String")

.getMethod("charAt", int.class);
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})形式。

六、通过反射调用main方法
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。
错误示例：

import java.lang.reflect.Method;
public class ReflectTest {

	public static void main(String[] args) throws Exception {

		String startingClassName = "com.itheima.day1.TestArguments";
		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"}});
拆包之后只有new String[]{"xxx"}一个参数。
方法二：
mainMethod.invoke(null,(Object)new String[]{"xxx"});

编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。

正确示例：

import java.lang.reflect.Method;
class ReflectTest {

	public static void main(String[] args) throws Exception {

		String startingClassName = "demo.TestArguments";
		Method mainMethod = Class.forName(startingClassName).getMethod("main",
				String[].class);
		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);
		}
	}
}

七、数组的反射
1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
示例：

public class ReflectTest {

	public static void main(String[] args) throws Exception {

		int[] a1 = new int[3];
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[3];
		
		System.out.println(a1.getClass() == a2.getClass());
		// 结果：true
		System.out.println(a1.getClass()==a4.getClass());
		// 编译器报错
		System.out.println(a1.getClass() == a3.getClass());
		// 编译器报错
	}
}

2、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

public class ReflectTest {

	public static void main(String[] args) throws Exception {

		int[] a1 = new int[3];
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[3];

		System.out.println(a1.getClass().getName());
		// 结果：[I
		System.out.println(a1.getClass().getSuperclass().getName());
		// 结果：java.lang.Object
		System.out.println(a4.getClass().getSuperclass().getName());
		// 结果：java.lang.Object
	}
}

3、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；

非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
示例：

public class ReflectTest {

	public static void main(String[] args) throws Exception {

		int[] a1 = new int[3];
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[3];
		Object aObj1 = a1;
		Object aObj2 = a4;

		// a1是int 类型的数组，int 不是Object，因此编译就会报错
		 Object[] aObj3 = a1;
		// a3是数组的数组，第二维数组也是一维数组，父类是Object，因此不会报错
		Object[] aObj4 = a3;
		// a4是String的数组，String父类是Object，因此不会报错
		Object[] aObj5 = a4;
	}

}

4、Arrays.asList()方法处理int[]和String[]时的差异。
示例代码：

int[] a5 = new int[]{ 1, 2, 3 };
String[] a6 = new String[]{ "a", "b", "c" };
System.out.println(Arrays.asList(a5));
// 结果：[[I@18a992f]
System.out.println(Arrays.asList(a6));
// 结果：[a, b, c]

原因分析：

是因为JDK1.4中为Arrays.asList(Object[] a)，JDK1.5中为Arrays.asList(T... a)。
a5是int[]类型，JDK1.4中的asList方法处理不了，JDK1.5可以处理。但是JDK1.5将
int数组整体作为一个参数进行处理。

5、Array工具类用于完成对数组的反射操作。
示例：

public class ReflectTest {

	public static void main(String[] args) throws Exception {
		String[] a1 = new String[] { "a", "b", "c" };
		String a2 = "xyz";
		printObject(a1);
		printObject(a2);
	}

	public static void printObject(Object obj) {
		Class clazz = obj.getClass();
		if (clazz.isArray()) {
			int len = Array.getLength(obj);
			for (int i = 0; i < len; i++) {
				System.out.println(Array.get(obj, i));
			}
		} else {
			System.out.println(obj);
		}
	}
}

八、框架的概念及用反射技术开发框架的原理

我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，

用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，

工具类被用户的类调用，而框架则是调用用户提供的类。

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？

我写的框架程序怎样能调用到你以后写的类（门窗）呢？

因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接

new 某个类的实例对象V 了，而要用反射方式来做。

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;

public class ReflectTest {
       public static void main(String[] args) throws Exception {
       InputStream is = new FileInputStream("config.properties" );
         Properties props = new Properties();
         props.load(is);
         is.close();
         String className = (String)props.get( "className");
         Collection collections = (Collection)Class.forName(className).newInstance();
         ReflectPoint pt1 = new ReflectPoint(3, 3);
         ReflectPoint pt2 = new ReflectPoint(5, 5);
         ReflectPoint pt3 = new ReflectPoint(3, 3);
         collections.add(pt1);
         collections.add(pt2);
         collections.add(pt3);
         collections.add(pt1);

         System. out.println(collections.size());

       }

}

------------android培训、java培训、期待与您交流！--------------