java高新技术-反射
一、反射的基石->Class类
定义一个类使用 class
有一个类叫Class
Java程序中的各个Java类属于同一类事务，描述这类事物的Java类名就是Class。
Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，Class类代表Java类，
它的各个实例对象又分别对应什么呢？
->对应各个类在内存中的字节码，例如，Person的字节码，ArrayList类的字节码...
->一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的
所以他们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象类表示，这些对象显然具有相同的类型
1.类的字节码
Class cls1 = 字节码1;
Class cls2 = 字节码2;
Class的实例对象代表内存里的一份字节码；
什么叫字节码？
Person p1 = new Person();
当我们在源程序中用到了Person这个类的时候，会把编译好的二进制代码(.class)加载到内存中，接着才能用它创建一个个的对象。
加入用到了 Person Date Math 三个类，就会在内存中存在3份字节码，即每一份字节码都是一个Class类的实例对象。
Class cls1 = Date.class
Class cls2 = Person.class
获取字节码的方式有3种：
① 类名.class 例如： Date.class; //使用Date.class获取类的字节码(类.class)
② 对象.getClass() 例如：Person p1 = new Person();
p1.getClass(); //获取类的字节码
③ Class.forName("类名")，例如：Class.forName("java.lang.String") //获取类的字节码
面试题：Class.forName()的作用
使用Class.forName() 返回类的字节码，获取时有两种情况：
①.类的字节码已经被加载过，在java虚拟机中，不需要加载可以直接返回
②.JVM中还没有字节码，用类加载器加载，把加载进来的字节码缓存到JVM中，以后要得到字节码就不用再加载了
每一个字节码都是一个Class的实例对象
2.有九个预定义的Class实例对象
8个基本类型（byte, short, boolean ,char, int, long, float,double）
和void
3.数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[] ,void...
public static void main(String[] args) throws Exception{ String str1 = "abc"; Class cls1 = str1.getClass(); Class cls2 = String.class; Class cls3 = Class.forName("java.lang.String"); //3种方式都是同一份字节码 System.out.println(cls1 == cls2); System.out.println(cls1 == cls3); //isPrimitive 是否是基本类型 System.out.println(cls1.isPrimitive()); //flase System.out.println(int.class.isPrimitive()); //true System.out.println(int.class == Integer.class); //false //Integer.TYPE 代表包装类的基本类型的字节码 System.out.println(int.class == Integer.TYPE); //true System.out.println(int[].class.isPrimitive()); // flase System.out.println(int[].class.isArray()); //true }
二、反射
反射就是把Java类中的各种成分映射成相应的java类（Field,Method,Contructor,Package...）。
Method 的对象就是一个具体的方法
我们通过写程序可以得到这个类里面的各个成分所对应的类的对象
1.构造方法的反射应用
一个Class代表一个字节码，一个Method代表这个字节码里的一个方法，一个Contructor就代表一份自己码里的构造方法
得到某个类所有的构造方法：
例子：Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
获取指定构造方法，并调用构造方法：
//new String(new StringBuffer("abc")) Constructor constructor = String.class.getConstructor(StringBuffer.class); String str2 = (String)constructor.newInstance(new StringBuffer("abc")); System.out.println(str2.charAt(2));
如果改成：
//new String(new StringBuffer("abc")) Constructor constructor = String.class.getConstructor(StringBuffer.class);//获取构造方法时需要类型 String str2 = (String)constructor.newInstance("abc"); //调用构造方法时需要传递同样类型的对象 System.out.println(str2.charAt(2));
会报如下错误：
Exception in thread "main" java.lang.IllegalArgumentException: argument type mismatch at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:526) at com.java.enhance.ReflectTest.main(ReflectTest.java:23)
表示类型不匹配，获取构造方法时传的是StringBuffer.class
Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstacne();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象.
该方法内部的具体代码是怎样写的呢？ 用到了缓存机制来保存默认的构造方法的实例对象。
2.成员变量的反射
ReflectPoint.java
public class ReflectPoint { private int x; public int y; public ReflectPoint(int x, int y) { super(); this.x = x; this.y = y; } }
ReflectTest.java
ReflectPoint pt1 = new ReflectPoint(3, 5); Field fieldY = pt1.getClass().getField("y"); //fieldY不是对象身上的变量，而是类上，要用它去取某个对象对应的值 System.out.println(fieldY.get(pt1)); //由于x是private修饰，会报错 java.lang.NoSuchFieldException: x， // Field fieldX = pt1.getClass().getField("x"); // System.out.println(fieldX.get(pt1)); //获取私有变量 暴力反射 Field fieldX = pt1.getClass().getDeclaredField("x"); fieldX.setAccessible(true); System.out.println(fieldX.get(pt1));
3.成员变量反射的综合案例
public class ReflectPoint { private int x; public int y; public String z = "basketball"; public String z1 = "abc"; public ReflectPoint(int x, int y) { super(); this.x = x; this.y = y; } /* * (non-Javadoc) * * @see java.lang.Object#toString() */ @Override public String toString() { return "ReflectPoint [x=" + x + ", y=" + y + ", z=" + z + ", z1=" + z1 + "]"; } }
将对象中的String类型的成员变量所有的字符b换为字符a
public static void main(String[] args){
exchangeCharValue(pt1); System.out.println(pt1); } //将对象中的String类型的成员变量所有的字符b换为字符a private static void exchangeCharValue(Object obj) throws Exception { Field[] fields = obj.getClass().getFields(); for(Field field : fields){ // if(field.getType().equals(String.class)){ if(field.getType() == String.class){ //这里用 == 比equals更准确，字节码只有一份自己和自己比较 String oldValue = (String)field.get(obj); String newValue = oldValue.replace('b', 'a'); field.set(obj, newValue); } } }
4.成员方法的反射
String str1 = "abc";
Method chartAtMethod = Class.forName("java.lang.String").getMethod("charAt", int.class); //通常方式 System.out.println(str1.charAt(1));//b //反射方式 System.out.println(chartAtMethod.invoke(str1, 1));
System.out.println(methodCharAt.invoke(str1, new Object[]{2})); //c
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是没有可变参数
如果传递给Method对象的invoke()方法的第一个参数为null,这有着什么意义呢？
说明该Method对象对应的是一个静态方法！
5.对接受数组参数的成员方法进行反射
目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。
用普通法师调用完后，要明白为什么要用反射方式去调用？
public static void main(String[] args) throws Exception{ String startingClassName = args[0]; Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class); mainMethod.invoke(null, (Object)new String[]{"111","222","333"});
mainMethod.invoke(null, new Object[]{new String[] { "111", "222", "333" }}); }
添加参数
问题：
启动Java程序的main方法的参数是一个字符串数组，及public static void main(String[] args),
通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，
而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会
到底按照那种语法进行处理？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.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中传了一个数组作为实参，对呗拆包成为多个参数。
所以，在给main方法传递参数时，不能使用代码 mainMethod.invoke(null,new String[]{"xxx}),javac
只会把他当做jdk1.4的语法进行理解，而不是把它当做jdk1.5的语法解释，因此会出现参数类型不对的问题。
解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"});
编译器会做特殊处理，编译时不把参数当做数组看待，也就不会把数组打散成若干个参数了。
6.数组的反射
int[] a1 = new int[]{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()); //true 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 System.out.println(Arrays.asList(a1));//[[I@206c2ea3] System.out.println(Arrays.asList(a4)); //[a, b, c] Object aObj1 = a1; Object aObj2 = a4; Object[] aObj4 = a3; Object[] aObj5 = a4;
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用，非基本类型的一维数组，即可以当作Object类型使用，又可以当作Object[]类型使用。
Arrays.asList()方法处理int[] 和String[]时的差异
Arrays.asList(new String[]{"a","b","c"}) => [a,b,c]
Arrays.asList(new int[]{1,2,3}) =>[I@xxxxxxx(哈希Code码)
处理String[] 时使用的是jdk1.4的语法(当作Object[]，1.4没有可变参数的概念，使用的是Object[]当作参数)，处理int[] 时用的jdk1.5的语法(当作Object一个参数来处理，有可变参数的概念，使用的是Object...args)
7.数组反射的应用
private void printObject(Object obj){ Class clazz = obj.getClass(); if(class.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); } }
思考：
怎么得到数组中的元素类型？
没有办法得到数组中元素类型。
int[] a = new int[3];
Object[] a = new Object[]{"a",1}
只能得到某一个元素的类型 a[0].getClass().getName();
8. ArrayList_HashSet的比较及Hashcode分析
hashCode()方法的作用
public static void main(String[] args) { Collection collection = new HashSet<>(); ReflectPoint pt1 = new ReflectPoint(3, 3); ReflectPoint pt2 = new ReflectPoint(5, 5); ReflectPoint pt3 = new ReflectPoint(3, 3); collection.add(pt1); collection.add(pt2); collection.add(pt3); collection.add(pt1); // pt1.y = 7; //修改后hashCode值就不同了，导致找不到这个对象了，也无法删除 collection.remove(pt1); /**
1.如果实体类只重写了equals(),没有重写hashCode() 则collection总的个数为3
因为，在存储一个对象进HashSet中时，如果没有重写hashCode方法，导致两个对象计算出来的hashCode值是不相同的（hashCode值是根据对象在内存中的地址计算出来的）
我在我的区域里边找，不在那个已经存储同样对象的区域里边找，所以这个对象还是会被存储进去
为了让相等的对象找到在相同的区域，就有一个说法，如果两个对象的equals相等时，应该让他们的hashCode也应该相等
如果对象没有要存到hash集合里边，就没必要重写hashCode();
* 如果要放入HashSet中的对象没有重写hashCode方法和equals方法， * 两个对象的引用不同，还是会存入HashSet中，默认的equals方法使用 == 比较两个对象的内存地址值 * 如果重写hashCode与equals方法，会认为是相同的对象，后边要存入的存入不了 * * 当一个对象被存进HashSet集合中后，就不能修改这个对象中参与计算哈希值的字段了，否则，对象 * 修改后的哈希值与最初存进HashSet集合中的哈希值就不同了，在这种情况下，即使在 * contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回 * 不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄漏。 */ System.out.println(collection.size()); /** * 通常来说，一个类的两个实例对象用equals()方法比较的结果相等时，他们的哈希吗也必须相等，但 * 反之则不成立，及equals方法比较结果不相等的对象可以有相同的哈希码，或者说哈希吗相同的两个对象， * equals方法比较的结果可以不相同，例如 字符串"BB"和"Aa"的equals比较结果不相同，但hashCode()结果相等。 */ System.out.println("BB".hashCode()); // System.out.println("Aa".hashCode()); }
内存泄漏的问题也可以用此例子举例，
所谓内存泄漏，就是这个对象不再使用了可一直占用内存空间，无法释放掉。
9.反射的作用 -> 实现框架的功能
例如：要调用某个类的main方法，但是不知道要调用哪个类，这个类是动态传过来的，就类似一个小的框架。
你调用别人写的类，与别人调用你写的类，一个叫工具，一个叫框架（框架调用你的类）
框架与框架要解决的核心问题
-> 我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架要解决的核心问题
-> 因为在写程序时无法知道要调用的类名，所以，在程序中无法直接 new 某个类的实例对象了，而要用反射（Class.forName()）的方式类做。
public static void main(String[] args) throws Exception{ InputStream is = new FileInputStream("config.properties"); //尽量面向父类或面向接口编程 /** * Perperties类似于HashMap，比HashMap多了点功能，可以把内存中的键值对存到硬盘的文件中去, * 也可以在初始化时把硬盘中的键值对文件加载到内存中 */ Properties props = new Properties(); props.load(is); /* * 马上关闭资源，否则会有一点小小的内存泄漏 * 这个内存泄漏不是对象没有被释放，而是对象关联的系统资源没被释放 */ /* * 告诉系统把关联的系统资源干掉，本对象有可能还在，后续由垃圾回收释放掉 * 自己在垃圾回收之前，先把自己关联的系统资源释放掉 */ is.close(); String className = props.getProperty("className"); Collection collection = (Collection)Class.forName(className).newInstance(); }
config.properties
className=java.util.ArrayList
10.用类加载器的方式管理资源和配置文件
上述代码中的 InputStream ips = new FileInputStream("config.properties");在项目开中不会这么搞，一般要用完整的路径，但完整的路径不是硬编码，而是运算出来的。
.class 需要被类加载器加载到内存中，类加载器会提供一个方法加载普通文件。
InputStream is = ReflectTest2.class.getClassLoader().getResourceAsStream("config.properties");
使用getClassLoader()这种方式时，需要把配置文件放在classpath目录下，因为getClassLoader加载.class文件就是在classpath目录下加载，所以当然加载配置文件时也需放到classpath目录下
getResourceAsStream(),是在在classpath指定的目录下逐一查找需要加载的文件。
此时config.properties文件需放在src目录下，如果放在包下，需要写上目录名getResourceAsStream("com/java/config.properties")，在使用eclipse时会自动将配置文件复制到classpath目录下，真正在运行时用的是classpath目录下
也可以使用：
InputStream is = ReflectTest2.class.getResourceAsStream("config.properties"); //表示与当前类所在目录的相对路径下，即应该与当前类在同一个目录，用自己的类加载的时候可以用相对也可以用绝对，其内部还是使用的getClassLoader(),大部分框架内部都是使用类加载器加载配置文件，如果使用Eclipse开发，放在src目录下会自动拷贝的classpath目录下。
