反射
反射就是把Java类中的各种成分映射成相应的java类。例如，一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象有什么用？怎么用？这是学习和应用反射的要点。
反射的基础——Class类
Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中的各个Java类，它们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class,要注意与小写class关键字的区别哦。Class类描述了哪 些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。学习反射，首先要明白Class这个类。
Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
Person p1 = new Person();
Date
Math
Class cls1 = Date.class; //字节码1
Class cls2 = Person.class; //字节码2
Class.forName(”java.lang.String”)
Class.forName的作用是返回字节码，返回的方法有二种，第一种是这个类的字节码已经加载到内存中，直接调用返回。第二种是在虚拟机里还没有这个类的字节码，用类加载器去加载
如何得到各个字节码对应的实例对象(Class类型)
类名.claass 例如：System.class
对象.getClass() 例如：new Date().getClass()
Class.forName(”类名”) 例如：Class.forName(”java.util.Date”)[做反射用这种]
九个预定义Class实例对象【8个基本数据类型和一个void】
Int.class == Integer.TYPE
public class ReflectTest {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
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);
System.out.println(cls1.isPrimitive());
System.out.println(int.class.isPrimitive());
System.out.println(int.class == Integer.class);
System.out.println(int.class == Integer.TYPE);
System.out.println(int[].class.isPrimitive());
System.out.println(int[].class.isArray());
}
}
数组类型的Class实例对象用的是Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如：int[]、void...
Constructor类
Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法：
Constructor []constructors = Class.forName(”java.lang.String”).getConstructor();
得到某一个构造方法：
Class.forName(”java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时要用到类型
创建实例对象：
通常方式：String str = new String(new StringBuffer(”abc”));
反射方式：Constructor constructor = String.class.getConstructor(StringBuffer.class);
String str = (String)constructor.newInstance(new StringBuffer(”abc”));
//调用获得的方法时要用到上面相同类型的实例对象。
Class.newInstance()方法：
例：String obj = (String)Class.forName(”java.lang.String”).newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。
Field类
Field类代表某个类中的一个成员变量
来看一个例子：
package cn.itcast.day1;
import java.lang.reflect.Field;
public class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ReflectPoint pt1 = new ReflectPoint(3, 5);
Field fieldY = pt1.getClass().getField("y");
// fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值
System.out.println(fieldY.get(pt1));
Field fieldX = pt1.getClass().getDeclaredField("x");// x为私有变量
fieldX.setAccessible(true);// 暴力反射
System.out.println(fieldX.get(pt1));
}
}
练习1：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的”b”改成”a”。
package cn.itcast.day1;
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 "ReflectPoint [x=" + x + ", y=" + y + ", str1=" + str1
+ ", str2=" + str2 + ", str3=" + str3 + "]";
}
}
package cn.itcast.day1;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
ReflectPoint pt1 = new ReflectPoint(3,5);
Field fieldY = pt1.getClass().getField("y");
//fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值
System.out.println(fieldY.get(pt1));
Field fieldX = pt1.getClass().getDeclaredField("x");//x为私有变量
fieldX.setAccessible(true);//暴力反射
System.out.println(fieldX.get(pt1));
changeStringValue(pt1);
System.out.println(pt1);
}
private static void changeStringValue(Object obj) throws Exception{
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//if(field.getType().equals(String.class))
//对于字节码的比较用==，因为它只有一份,同样的字节码
if(field.getType() == String.class){
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}
}
}
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对象对应的是一个静态方法！
小程序：
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
String str1 = "abc";
//str1.charAt(1)
Method methodCharAt = String.class.getMethod("charAt", int.class);
methodCharAt.invoke(str1, 1);//这个invoke是方法对象上的一个方法
}
输出结果：b
练习2：用反射方式执行某个类中的main方法
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。
为什么要用反射？因为我不知道传入的类名是什么。
package com.xue.test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception{
//TestArguments.main(new String[]{"111","222","333"});//正常调main
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"});//这样也行
}
}
class TestArguments{
public static void main(String[] args){
for(String arg : args){
System.out.println(arg);
}
}
}
这步不要忘记操作，就是把这个类名当成字符串传给ReflectTest这个类。
数组反射
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用;非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作。
package com.xue.test;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception{
String[] a4 = new String[]{"a","b","c"};
printObject(a4);
System.out.println("*****************");
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);
}
}
}
思考：怎么得到数组中的元素类型？
不可以。
int[] a = new int[3]
Object[] a = new Object[]{“a”,1}
这里想得到整个数组的类型是不可以的，如果是想得到某一个具体的类型是可以的，比如
a[0].getClass().getName();
