黑马程序员----[20150513][反射]

最新推荐文章于 2021-02-13 16:57:13 发布

天意难违

最新推荐文章于 2021-02-13 16:57:13 发布

阅读量281

点赞数

分类专栏： javase 文章标签：反射

本文链接：https://blog.csdn.net/ninchen/article/details/45690511

版权

javase 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

反射

1.反射的基础_Class类

反射的基石->Class类

Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
Class类描述了那些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表，等等。

Class实例对象代表的是内存中的一份字节码。当原程序用到Person这个类时，首先源码会编译成class文件放在硬盘上，接着这些二进制代码会加载到内存中，接着用这些创建一个个的对象。当用到了好多的类，那么内存中就有好多个份字节码。那么每个份字节码就是一个Class的实例对象。

例如：Class cls1 = Date.class//字节码1 Class cls2 = Person.class//字节码2

p1.getClass()//这个方法就能通过对象来得到本对象是哪个字节码实例出来的。//这个是内存中已经加载了

Class.forName("java.lang.String")//这个方法是另一个形式得到这个类的字节码。//这个是内存中没有加载，现加载的！

如何得到各个字节码对应的实例对象（Class类型）

类名.class,例如，System.class
对象.getClass(),例如，new Date().getClass()
Class.forName("l类名")，例如，Class.forName("java.util.Date");

例如：

		String str1 = "abc";
		Class cls1 = str1.getClass();
		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1 == cls2);
		System.out.println(cls1 == cls3);

九个预定义Class实例对象：

参看Class.isPrimitive方法的帮助
Int.class == Integer.TYPE
数组类型的Class实例对象。Class.isArray()

System.out.println(cls1.isPrimitive());//String不是基本类型，返回false

System.out.println(int.class.isPrimitive());//int是基本类型，返回true

System.out.println(Integer.class.isPrimitive());//Integer不是基本类型，返回false

System.out.println(Integer.TYPE.isPrimitive());//Int.class == Integer.TYPE，返回true

System.out.println(int[].class.isPrimitive());//int[]数组不是基本类型，返回false

System.out.println(int[].class.isArray());//isArray()方法是判断一个calss是不是数组，返回true

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[],void....

2.反射的概念

反射就是把Java类中各种成分映射成相应的java类。例如，一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就行汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造函数，修饰符，包等信息，这些信息就是用相应的实例对象来表示，它们是Field、Methed、Contructor、Package等等。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

3.构造方法的反射

构造方法的反射：
思路：class------>constructor-------->new object

Constructor类代表某个类中的一个构造方法

得到某个类中多有的构造方法：例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：例子： Constructor [] constructors= Class.forName("java.lang.String").getConstructors(StringBuffer.class);
创建实例对象：

通常方式：String str=new String("abc");
反射方式：String str=(String)constructor.newInstance(newStringBuffer("abc"));

//new String(new StringBuffer("abc"));
Constructorconstructor1=String.class.getConstructor(StringBuffer.class);
String str2=（String）constructor1.newInstance(new StringBuffer("abc"));

第一个StringBuffer代表选择哪个构造方法
第二个StringBuffer代表用这个StringBuffer时还要传递一个StringBuffer对象

Class.newInstance()方法：
例子：String obj=（String）Class.forName(“java.lang.String”).newInstance();
1. 该方法内部先得到默认的构造方法，然后调用该方法创建实例对象。
2. 该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

4.成员变量的反射

Field类代表某个类的中一个成员变量

publicclass ReflectpoiSecond {
    private int x;
    public int y;
	
    public ReflectpoiSecond(int x, int y) {
       super();
       this.x = x;
       this.y = y;
    }
}

publicclass ReflectTest {
    public static void main(String[] args) throws Exception {
            ReflectpoiSecond pt1 =new ReflectpoiSecond(3,5);
			
			Field fieldY = pt1.getClass().getField("y");
			//getField对于私有的变量是无效的。
			//fieldY的值是多少？是5，错!
			//fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值。

			System.out.println(fieldY.get(pt1));
			
			
			Field fieldX = pt1.getClass().getDeclaredField("x");
			//getDeclaredField得到变量，不管私有还是公有。
			
            fieldX.setAccessible(true);//设置访问权限 ---暴力反射	
            System.out.println(fieldX.get(pt1));
   }
}

5.成员变量反射案例

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

public class ReflectPoint {

	public String str1 = "ball";
	public String str2 = "basketball";
	public String str2 = "itcast";

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


private 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);
		}
	}
}

public class Test {

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

		ReflectPoint pt1 = new ReflectPoint();
		changeStringValue(pt1);
		
		System.out.println(pt1);	
	}
}

6.成员方法的反射

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[] getMethods();//只获取公共和父类中的方法。

Method[] getDeclaredMethods();//获取本类中包含私有。

Method  getMethod("方法名"，参数.class（如果是空参可以写null）);

4、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方法时。

通过思考和推理来学习反射中的API。
例如，Class.getMethod方法用于得到一个方法，该方法要接收什么参数呢？显然要一个方法名。
而一个同名的方法有多个重载形式，用什么方式可以区分清楚想得到重载方法列表中的哪个方法呢？
根据参数的个数和类型，例如，Class.getMethod(name,Class...args);
args参数就代表所要获取的哪个方法的各个参数的类型的列表。
强调：参数类型是用Class对象来表示的！

import java.lang.reflect.*;
class ReflectMethod 
{
	public static void main(String[] args) throws Exception
	{
		String str1 = "abc";

		//str1.charAt(1);
		Method methodCharAt = String.class.getMethod("charAt",int.class);
				
		System.out.println(methodCharAt.invoke(str1,1));	
		//下面是按jdk 1.4 的语法来调用
		System.out.println(methodCharAt.invoke(str1,new Object[]{2}));

	}
}

7.main方法的反射

目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。思考为什么要用反射方式去调。

问题：启动java程序的main方法的参数是一个字符串数组，即public static void main(String[] args),通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按照jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法。所以，在给main方法传递参数时，不能使用代码：mainMethod.invoke(null,new String[]{"xxxx"}),javac只会把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5语法理解。因此会出现参数类型不对的问题。

解决办法：

mainMethod.invoke(null,new Object[]{new String[] {"xxx"}});
mainMethod.invoke(null,(Object)new String[] {"xxx"});

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

import java.lang.reflect.*;
class ReflectMain 
{
	public static void main(String[] args) throws Exception
	{		
		//通常方式：
		//TestArguments.main(new String[]{"111","222","333"});
		String startingClassName =  args[0];
		Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);
		//mainMethod.invoke(null,new Object[]{new String[]{"111","222","333"}});
		mainMethod.invoke(null,(Object)new String[]{"111","222" ,"333"});//(Object)是对jvm说，我这是个对象，不要当成一个数组，别拆包
		//这里运行时要把类名当做参数传递进去，java ReflectMain TestArguments 
	}
}

class TestArguments 
{
	public static void main(String[] args) 
	{
		for (String arg : args)
		{
			System.out.println(arg);
		}	
	}
}

8.数组的反射

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

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

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

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

5、Array类用于完成对数组的反射操作。

6、思考题：怎么得到数组中的元素类型？答案：得不到！因为：

Object [] a = new Object[] {"a",1};
a[0].getClass().getName();

import java.lang.reflect.*;
import java.util.*;
class ReflectArray 
{
	public static void main(String[] args) 
	{
		int[] a1 = new int[]{1,2,3}; 
 		Integer[] a11 = new Integer[]{1,2,3};
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String [] a4 = new String[]{"a","b","c"};

		System.out.println(a1.getClass()==a2.getClass());			
		System.out.println(a1.getClass().equals(a4.getClass()));//这里如用==则报错
		System.out.println(a1.getClass().equals(a3.getClass()));
		System.out.println(a1.getClass().getName());	
		System.out.println(a1.getClass().getSuperclass().getName());			
		System.out.println(a4.getClass().getSuperclass().getName());
		
		Object aObj1 = a1;
		Object aObj2 = a4;
		//Object[] aObj3 = a1;
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;

		System.out.println(a1);	
		System.out.println(a4);	

		//按jdk1.5中的，asList(T...a),把a1(即一个基本数据类型的数组)
		//当成一个Object作为参数传进去了
		System.out.println(Arrays.asList(a1));	

		//这里按jdk1.4中，asList(Object[] a),把a4字符串数组中的
		//每个字符串当作一个Object，合成一个Object数组作为参数传进去
		//区别原因：基本数据类型不是Object，而字符串是Object
		System.out.println(Arrays.asList(a4));	
		
		//如果把int[]改成 Integer[],就可以把数组中的元素当作一个Object了。
		System.out.println(Arrays.asList(a11));	

		//数组的反射应用
		Object obj = null;
		printObject(a1);	
		printObject(a4);	
		printObject("xyz");
	}

	private 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);
	}

9.Array_HashSet的比较及Hashcode分析

如果想查找一个集合中是否包含某个对象，大概的程序代码怎样写呢？你通常是逐个取出每个元素与要查找的对象进行比较，当发现某个元素与要查找的对象进行equals方法比较的结果相等时，则停止继续查找并返回肯定信息，否则，返回否定信息。如果一个集合中有很多个元素，如有一万，并且没有包含要查找的对象时，则意味着你的程序需要从该集合中取出一万个元素进行逐个比较才能得到结论。有人发明了一种哈希算法来提高从集合中查找元素的效率，这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在哪个区域，如图：

HashSet就是采用哈希算法存取对象的集合，它内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域。Object类中定义了一个hashCode()方法来返回每个java对象的哈希码，当从HashSet集合中查找某个对象时，Java系统首先调用对象的hashCode方法获得该对象的哈希码，然后根据哈希码找到相应的存储区域，最后取出该存储区域内的每个元素与该对象进行equals方法比较，这样不用遍历集合汇总的所有元素就可以得到结论。
可见，HashSet集合具有很好的对象检索性能,但是，HashSet集合存储对象的效率相对低些。

import java.util.*;
class ReflectArrayList 
{
	public static void main(String[] args) 
	{
		//Collection collections = new ArrayList();		
		Collection collections = new HashSet();

		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); 
		
		//ArrayList时，结果为4，因为它是有序的，允许元素重复。
		//HashSet时，结果为3，因为它是无序的，元素不允许重复。
		//当覆盖hashCode和equals方法后，结果为2，因为pt3和pt1重复，故没放进去
		System.out.println(collections.size());
	}
}

ReflectPoint.java文件：

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//覆盖hashCode方法
	public int hashCode() {  
        final int prime = 31;  
        int result = 1;  
        result = prime * result + x;  
        result = prime * result + y;  
        return result;  
    }  

	@Override//覆盖equals方法
    public boolean equals(Object obj) {  
        if (this == obj)  
            return true;  
        if (obj == null)  
            return false;  
        if (getClass() != obj.getClass())  
            return false;  
        final ReflectPoint other = (ReflectPoint) obj;  
        if (x != other.x)  
            return false;  
        if (y != other.y)  
            return false;  
        return true; 
	}
	
	
	@Override
	public String toString()
	{
		return str1 + ":" +str2 + ":" + str3;
	}
	
}

10.框架与反射

1、框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架。用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别：工具类被用户的类调用，而框架则是调用用户提供的类。

2、框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序。我写的框架程序怎么样才能调用到你以后写的类（门窗）呢？因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。