黑马程序员 java学习笔记——反射

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

Class类

概念

java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的具体值是多少，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。
那么一个问题出现了。
java程序中的各个类，他们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？
答案是肯定的。
java程序的各个java类当然属于同一类事物，而描述这类事物的java类就是Class。
PS：注意与小写class关键字的区别。
那么，Class类描述了哪些方面的信息呢？
有很多，如类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表，等等。

如何得到各个字节码对应的实例对象？

1、类名.class，例如System.class
2、getClass(),例如new Person().getClass();
3、Class.forName("类名"),例如：Class.forName("java.util.Data");

返回情况有两种：

①JVM已经加载了类的字节码，返回即可。

②JVM没有加载该类字节码，那么就用类加载器加载，然后把字节码信息缓存在JVM中，该方法返回刚才加载进来的字节码。

9个预定义的Class

8个基本数据类型.class+void.class

代码示例

public class Demo{
	public static void main(String[] args) throws Exception{
		String str="abc";
		Class c1=str.getClass();
		Class c2=String.class;
		Class c3=Class.forName("java.lang.String");
		
		sop(c1==c2);
		sop(c1==c3);

		sop(c1.isPrimitive());
		sop(int.class.isPrimitive());
		sop(int.class==Integer.class);
		sop(int.class==Integer.TYPE);
		sop(int[].class.isPrimitive());
		sop(int[].class.isArray());
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}
//true
//true
//false
//true
//false
//true
//false
//true

理解反射的概念

反射就是把java类中的各种成分映射到相应的java类。
例如，一个java类中用一个Class的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示，这就像汽车是一个类，汽车的发动机，变速箱等等也是一个个的类。表示java类的class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相信的实例对象来表示，它们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

构造方法的反射应用

Constructor类代表某个类中的一个构造方法。
1、得到某个类中的所有构造方法

例子：Constructor construction[]=Class.forName("java.lang.String").getConstructors();

2、得到某一个构造方法。

例子：Constructor construction=Class.forName("java.lang.String").getConstructor(StringBuffer.class);

3、创建实例对象

通常方式：String str=new String(new StringBuffer("abc"));

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

注意：调用获得的方法时，要用到上面相同类型的实例对象。

4、Class.newInstance()

例子：String str=(String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

该方法内部的具体代码是怎么样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

示例代码：

import java.lang.reflect.*;
public class Demo{
	public static void main(String[] args) throws Exception{
		Constructor cons=String.class.getConstructor(StringBuffer.class);
		String str=(String)cons.newInstance(new StringBuffer("abc"));
		sop(str.charAt(2));
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}
//c

成员变量的反射

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

示例代码

import java.lang.reflect.*;
class ReflectPoint{
	private int x;
	public int y;
	public ReflectPoint(int x,int y){
		this.x=x;
		this.y=y;
	}
}

public class Demo{
	public static void main(String[] args) throws Exception{
		ReflectPoint pt1=new ReflectPoint(3,5);
		Field fieldY=pt1.getClass().getField("y");
		sop(fieldY.get(pt1));
		Field fieldX=pt1.getClass().getDeclaredField("x");
		//暴力反射
		fieldX.setAccessible(true);
		sop(fieldX.get(pt1));
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

成员方法的反射

Method类

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[] argd);
需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可用JDK1.4改写为:charAt.invoke(“str”,new Object[]());

示例代码

import java.lang.reflect.*;
public class Demo{
	public static void main(String[] args) throws Exception{
		String str="abcd";
		Method m=String.class.getMethod("charAt",int.class);
		sop(m.invoke(str,2));
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

用反射执行某个类中的main方法

目标

写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。

问题

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

解决方法

1、mainMethod.invoke(null,new Object[]{new String[]{"abc"}})
2、mainMethod.invoke(null,(Object)new String[]{"abc"})，编译器会作特殊处理，编译时不把参数当做数组看待，也就不会把数组打散成若干个参数了。

示例代码

import java.lang.reflect.*;
public class Demo{
	public static void main(String[] args) throws Exception{
		String classname="DemoTwo";
		Method m=Class.forName(classname).getMethod("main",String[].class);
		m.invoke(null,new Object[]{new String[]{"111","222","333"}});
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

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

数组与Object的关系及其反射类型

1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
2、代表数组的Class实例对象的getSuperClass()方法返回父类为Object类对应的Class.
3、基本数据类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用，非基本类型的一维数组，既可以被当作Object类型使用，也可以当作Object[]类型使用。
4、Arrays.asList()方法处理int[] 和String[] 时的差异

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

示例代码

import java.lang.reflect.*;
public class Demo{
	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];
		sop(a1.getClass()==a2.getClass());
		sop(a1.getClass()==a3.getClass());
		sop(a1.getClass()==a4.getClass());

		sop(a1.getClass().getName());
		sop(a1.getClass().getSuperclass().getName());
		sop(a4.getClass().getSuperclass().getName());
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}
//true
//[I
//java.lang.Object
//java.lang.Objec

数组反射的应用

示例代码如下：

import java.lang.reflect.*;
public class Demo{
	public static void main(String[] args) throws Exception{
		int[] arr={1,2,3};
		sop(arr);
		sop("abc");
	}
	public static void sop(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);
	}
}
//1
//2
//3
//abc

ArrayList与HashSet的比较及Hashcode分析

ArrayList与HashSet

1、ArrayList类似于数组，带有下标，所以存入不同对象是可以指向同一个值的，也就是说可以存入相同对象。
2、HashSet底层是hash表的结构，不能存入相同对象，存入时先判断hashcode值，再判读equals值。

注意：只有类的实例对象要被采用哈希算法进行存储和检索时，这个类才需要按要求覆盖hashCode方法。

内存泄露

当一个对象被存储进HashSet集合中以后，就不能修改这个对象中哪些参与计算哈希值的字段了。否则，对象修改后的哈希值与最初存储进HashSet集合中的哈希值就不同了。在这种情况下，即使在contains方法是用该对象的当前引用作为参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。

示例代码

import java.lang.reflect.*;
import java.util.*;
class ReflectPoint{
	private int x;
	public int y;
	public ReflectPoint(int x,int y){
		this.x=x;
		this.y=y;
	}
	public int hashCode(){
		return x+y*33;
	}
	public boolean equals(Object obj){
		ReflectPoint pt=(ReflectPoint)obj;
		return (this.x+this.y)==(pt.x+pt.y);
	}
}
public class Demo{
	public static void main(String[] args) throws Exception{
		Collection coll1=new HashSet();
		Collection coll2=new ArrayList();
		ReflectPoint pt1=new ReflectPoint(1,2);
		ReflectPoint pt2=new ReflectPoint(3,4);
		ReflectPoint pt3=new ReflectPoint(1,2);
		

		coll1.add(pt1);
		coll1.add(pt2);
		coll1.add(pt3);
		coll1.add(pt1);
		
		coll2.add(pt1);
		coll2.add(pt2);
		coll2.add(pt3);
		coll2.add(pt1);

		System.out.println("coll1的大小："+coll1.size());
		System.out.println("coll2的大小："+coll2.size());
	}
}
//coll1的大小:2
//coll2的大小:4

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

反射的作用：实现框架功能

框架

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

框架要解决的核心问题

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

综合案例

1、先直接用new 语句创建ArrayList和HashSet的实例对象。用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
2、然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
3、引入了elipse对资源文件的管理方式。建立一个config.properties。当程序运行的时候，通过修改该文件，就可以运行想要运行的类。尽量面向接口编程。把程序要调用的类放在配置文件中，而在源程序中不要出现

代码示例

配置文件内容如下：
classname=java.util.ArrayList

import java.io.*;
import java.util.*;
import java.lang.reflect.*;

class ReflectPoint{
	private int x;
	public int y;
	public ReflectPoint(int x,int y){
		this.x=x;
		this.y=y;
	}
	public int hashCode(){
		return x+y*33;
	}
	public boolean equals(Object obj){
		ReflectPoint pt=(ReflectPoint)obj;
		return (this.x+this.y)==(pt.x+pt.y);
	}
}
public class Demo{
	public static void main(String[] args) throws Exception{
		InputStream is=new FileInputStream("abc.properties");
		Properties prop=new Properties();
		prop.load(is);
		String classname=prop.getProperty("classname");
		Collection coll=(Collection)Class.forName(classname).newInstance();
		ReflectPoint pt1=new ReflectPoint(1,2);
		ReflectPoint pt2=new ReflectPoint(3,4);
		ReflectPoint pt3=new ReflectPoint(1,2);

		coll.add(pt1);
		coll.add(pt2);
		coll.add(pt3);
		coll.add(pt1);
		System.out.println("coll的大小："+coll.size());
	}
}

----------------------  ASP.Net+Android+IO开发S 、 .Net培训 、期待与您交流！ ----------------------