黑马程序员 Java高新技术 反射总结

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------

什么是反射

“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。

但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，
Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射的基石(Class类)

Java程序中的各个Java类属于同一类事物，描述这类事物的Java类就是Class类。

Class类描述了类的名字，类的访问属性，类所属的包名，字段名称的列表(成员变量)，方法名称的列表等等。

得到字节码对应的实例对象(Class类型)的三种方式：

1.类名.class，例如，System.class

2.对象.getClass()，例如，new Date().getClass()
3.Class.forName("完整的类名")，例如，Class.forName("java.util.Date");
做反射时主要用第三种，因为在写源程序的时候还不知道类的名字，

在写源程序的时候把"java.util.Date"换成一个字符串类型的变量，

等程序运行时，变量的值可以从配置文件中装载进来。

九个预定义Class实例对象

基本的Java类型(boolean、byte、char、short、int、long、float和double)和关键字void也表示为Class对象。 
String str1 = "abc";
Class cls1 = str1.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true

System.out.println(cls1.isPrimitive());//false isPrimitive()用于判断字节码是不是基本类型的 
System.out.println(int.class.isPrimitive());//true
System.out.println(int.class == Integer.class);//false
System.out.println(int.class == Integer.TYPE);//true TYPE常量代表包装类对应的基本类型的字节码
System.out.println(int[].class.isPrimitive());//false
System.out.println(int[].class.isArray()); //true  数组也是一种类型

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

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

得到某一个构造方法：

//根据传入的参数类型(这里是类型需要加.class)，确定要得到的构造方法

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

创建实例对象：

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

//注意：需要强制类型转换，这里是对象不需要加.class

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

上面的方法需要先得到Constructor，再通过Constructor得到newInstance，

如果只是用默认的构造方法创建实例对象，java提供了简便方法

Class.newInstance()方法：

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

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

该方法内部用到了缓存机制来保存默认构造方法的实例对象。

Field类代表某个类中的一个成员变量
可以用eclipse自动生成Java类的构造方法 

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){
this.x = x;
this.y = y;
}
}
public class ReflectTest
{
public static void main(String[] args){
ReflectPoint point = new ReflectPoint(3,5);
Field fieldY =point.getClass().getField("y");/*注意:fieldY的值不是5，fieldY不是对象身上的变量，
而是类上的,要用它去取对象身上的变量*/
System.out.println(fieldY.get(point));//结果为5  把对象作为参数传进去，就可以取出对象身上的变量
Field fieldX =point.getClass().getField("x");//这句话会报错，因为x是私有的，不可见
Field fieldX =point.getClass().getDeclaredField("x");//使用getDeclaredField()可以访问不可见的
fieldX.setAccessible(true);//暴力反射  使用getDeclaredField()只能看到但是取不出，需要将其设置成可以访问
System.out.println(fieldX.get(point));//结果为3

changeStringValue(point);
}
//将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
private static void changeStringValue(Object obj){
Field[] fields = obj.getClass().getFields();
for (Field field : fields){
//比较字节码用==比equals更准确
if (field.getType() == String.class){
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b','a');
field.set(obj,newValue);
}
}
}
}

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})形式。

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

目标：

写一个程序，这个程序能够根据用户提供的类名，去执行该类中的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的语法解释，因此会出现参数类型不对的问题。

解决办法：
1.mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});

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

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

数组的反射及其与Object的关系
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

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

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

非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。

将int[]中的元素作为整体打印，结果为[[I@1cfb549]

而String[]中的元素都被打印了出来，结果为[a,b,c]

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

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

思考：怎么得到数组中的元素类型？

没有办法得到，只能得到某个具体的元素的类型。

小知识点：HashCode分析

通过HashCode将对象在集合中进行分区存储，查找时只需要到某个区域查找即可。
当对象被存储进HashSet集合中以后，就不能修改对象所在的类中那些参与计算哈希值的方法和变量了，

否则，将无法检索到之前的对象，这样会导致无法从HashSet集合中删除之前的对象，从而造成内存泄漏。

用反射技术开发框架的原理

写程序时调用别人的类，可以直接new实例对象。
写框架的话，根本不知道将来有什么类会被调用，这时就要用到反射。

框架可以理解为房子，盖房子是很困难的，想要简单盖得快就可以直接用别人的框架，

找个毛坯房自己装修安门窗，也可以得到自己想要的效果，实现自己需要的功能。

综合案例：

采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。

先定义一个config.properties文件，内容为：className=java.util.ArrayList

运行一次以后改为className=java.util.HashSet 
这算是一个简单的框架，只需要修改配置文件而不用修改源代码，体现出了框架和反射的优越性。 

public class ReflectPoint {
private int x;
private int y;
ReflectPoint(int x,int y){
this.x = x;
this.y = y;
}
//需要覆盖equals和hashcode方法，可以用eclipse自动生成
}
public class ReflectTest {
public static void main(String[] args) throws Exception {
InputStream ips = new FileInputStream("config.properties");
Properties props = new Properties();
props.load(ips);
ips.close();/*尽快关闭资源，读取完毕以后，如果java中的对象被垃圾回收机制
回收了，而Windows中的资源还没被关闭就会内存泄漏。*/
String className = props.getProperty("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());//使用ArrayList结果为4，改成HashSet以后结果为2.
}
}

管理配置文件
1.properties文件一定要用完整的路径，以后会学到getRealPath(); 通过这个方法

可以获得编写的程序文件所在的路径，然后把properties文件放到程序文件夹内部
2.将配置文件跟.class文件放在一起，通过类加载器加载配置文件，SSH三大框架都是用的这种方法，

InputStream ips = ReflectTest.class.getResourceAsStream("config.properties");

如果配置文件跟自己的文件有关系就用相对路径，没关系就需要写上完整的路径。

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------