黑马程序员——java反射机制

------<a href="http://www.itheima.com" target="lank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

java反射机制

 一、基础知识  

       反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。

     1.Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。                                     

     2.Java程序中各个Java类，它们是属于同一类事物，可以用一个类来描述这类事物,这个类的名字就是Class。Class类描述了类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。反射就是把Java类中的各个成分映射成相应的java类。

      3.一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象。每个java类都是Class的一个实例对象，它们的内容不同，但是，它们的特征相同，比如都有方法，有字段等。

Class的实例对象代表内存中的字节码 ：

二、字节码

   总结：字节码：.class加载到内存中才可以创建对象      eg: Class s=Date.class//字节码

    得到各个字节码对应实例的对象的三种方法：
   1、类名.Class 例如：System.class;
   2、对象名.Class 例如 new Date().getClass();
   3、静态方法Class.forName("类名"); 例如，Class.forName("java.util.Date");

  Class.forName()得到字节码的情况：
   1、字节码已经加载到java虚拟机中，去得到字节码
   2、java虚拟机中还没有生成字节码 用类加载器进行加载，加载的字节码缓冲到虚拟机中

    九个预定义Class的实例对象（byte.class char.classshort.class int.classlong.class float.class  double.class boolean.class和void.class）八个基本数据类型和void类型
在源程序中出现的类型，都有各自的Class实例对象，如int[],void…

isPrimitive();判断是否是基本类型的字节码

int.class和Integer.class不是同一份字节码，Integer.TYPE，TYPE代表包装类对应的基本类的字节码   int.class==Integer.TYPE

数组类型的Class实例对象 用到Class的isArray()

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

 

构造方法的反射：

思路：class------>constructor-------->new object

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

Constructor[]constructors=Class.forName("java.lang.String").getConstructors();

2.得到某一个构造方法

Constructor constructor=Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
3.创建实例对象：
        通常方式：String str=new String("abc");
        反射方式：Stringstr=(String)constructor.newInstance(newStringBuffer("abc"));

 Constructorconstructor1=String.class.getConstructor(StringBuffer.class);
   String str2=（String）constructor1.newInstance(newStringBuffer("abc"));
第一个StringBuffer代表选择哪个构造方法
第二个StringBuffer代表用这个StringBuffer时还要传递一个StringBuffer对象

Class.newInstance()方法：

例子：String obj=（String）Class.forName(“java.lang.String”).newInstance();

1.    该方法内部先得到构造方法，然后调用该方法创建实例对象。

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

成员变量的反射

publicclass ReflectTest {

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

           ReflectpoiSecondrs=new ReflectpoiSecond(4,5);

FieldfieldX=rs.getClass().getField("x");//getField提供可见的 FieldfieldY=rs.getClass().getDeclaredField("y");//getDeclaredField得到声明过的属性

           fieldY.setAccessible(true);//设置访问权限 ---暴力反射

           System.out.println(fieldX.get(rs));

           System.out.println(fieldY.get(rs));

   }}

成员方法的反射：Method类代表某个类中的一个成员方法：

  一．得到类中的某一个方法：

  MethodmethodCharAt=Class.forName("java.lang.String").getMethod("charAt",int.class);

 System.out.println(methodCharAt.invoke(str,1));//调用str对象中charAt(1)

   二．调用方法：
 1. 通常方式：System.out.println(str.charAt(1));
 2.反射方式：System.out.println(charAt.invoke(str,1));//str是一个对象，这里str可以是null,说明invoke()方法是一个静态方法

Jdk1.4和jdk1.5的invoke方法的区别：

JDK1.5:public Objectinvoke(Object obj,Obj…args);

JDK1.4:public Objectinvoke(Object obj,Object[] args);

   即按JDK1.4的语法，需要讲一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，charAt方法的代码也可以用JDK1.4改写为charAt.invoke(“str”,newObject[]{1})形式。

实例应用：用反射方式执行某个类中的main方法

1.目标：

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

2.问题

启动java程序的main方法的参数是一个字符串数组， 即public static void main(String[]args),通过反射方式来调用这个main方法时，按jdk1.5的语法，整个数组是一个参数，而jdk1.4的语法，数组的每个元素对应一个参数，当做把一个字符串数组作为参数传递给invoke方法如何处理（注意兼容）。所以，在给main方法传递参数时，不能使用代码mainMthod.invoke(null,newString[]{“xxxx”}),javac只把它当做JDK1.4的语法进行理解，。而不能把它当做JDK1.5的语法解释，因此，会出现参数类型不对的问题。
3.解决方法：
方法一：mainMethod.invoke(null,newObject[]{newString[]{xxxx}});
方法二：mainMethod.invoke)((Object)newString[]{"xxxx"});编译器会做特殊处理，编译时不把参数当做数组看待，也就不会数组达三成若干参数

数组的的反射

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

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

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

4.注意区别 Array.asList()方法处理int[]和String[]时的差异

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

反射实例演示：

public class ReflectTest {

 /**
  * @param args
  */
 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);
//打印结果为TRUE因为字节码文件相同  

//判断指定的class文件是否为一基本类型。
  System.out.println(cls1.isPrimitive());
  System.out.println(int.class.isPrimitive());

//结果为false，因为int为基本类型，Integer为一对象。
  System.out.println(int.class == Integer.class);

//结果为true，Integer.TYPE返回的是int基本类型的字节码文件。
  System.out.println(int.class == Integer.TYPE);

//结果为false，int[]是以基本类型数组。
  System.out.println(int[].class.isPrimitive());

//判断此class是不是一个数组类。
  System.out.println(int[].class.isArray());  
  
  //new String(new StringBuffer("abc"));

//获取构造方法
  Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
  String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
  System.out.println(str2.charAt(2));

  //String.class.newInstance()获取空参数的构造方法。
 

//获取成员变量。

 ReflectPoint pt1 = new ReflectPoint(3,5);
  Field fieldY = pt1.getClass().getField("y");
  //fieldY的值是多少？是5,错！fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值
  System.out.println(fieldY.get(pt1));

//获取公共权限的成员变量。
  Field fieldX = pt1.getClass().getDeclaredField("x");

//暴力反射，得到私有权限的成员变量
  fieldX.setAccessible(true);
  System.out.println(fieldX.get(pt1)); 
  
  changeStringValue(pt1);
  System.out.println(pt1);
  

//获取方法。
  Method methodCharAt = String.class.getMethod("charAt", int.class);
  System.out.println(methodCharAt.invoke(str1, 1));
  System.out.println(methodCharAt.invoke(str1, new Object[]{2}));
  

//获取主函数方法。
  //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"});
  

//数组变量的字节码文件，相同维数的数组的字节码文件相同
  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());
  System.out.println(a1.getClass() == a4.getClass());
  System.out.println(a1.getClass() == a3.getClass());
  System.out.println(a1.getClass().getName());

//通过字节码文件获取父类名。
  System.out.println(a1.getClass().getSuperclass().getName());
  System.out.println(a4.getClass().getSuperclass().getName());
  

//通过以上验证得出，数组的父类是Object
  Object aObj1 = a1;
  Object aObj2 = a4;
  //Object[] aObj3 = a1;
  Object[] aObj4 = a3;
  Object[] aObj5 = a4;
  
  System.out.println(a1);
  System.out.println(a4);
  System.out.println(Arrays.asList(a1));
  System.out.println(Arrays.asList(a4)); 
  
  printObject(a4);
  
  printObject("xyz");
 }

//通过反射机制打印数组。

 private static void printObject(Object obj) {

//获取对象的字节码文件。
  Class clazz = obj.getClass();

//判断class是否为一个数组。
  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);
  }
  
 }

//如果obj为一字符串，改变其中字符a和b的位置，返回一新的字符串。

 private static void changeStringValue(Object obj) throws Exception {

//获取obj 的成员变量
  Field[] fields = obj.getClass().getFields();
  for(Field field : fields){
   //if(field.getType().equals(String.class)){

//判断成员变量的类型是否为String类型。
   if(field.getType() == String.class){
    String oldValue = (String)field.get(obj);

//通过交换位置获取新的字符串。
    String newValue = oldValue.replace('b', 'a');
    field.set(obj, newValue);
   }
  }
  
 }

}

//遍历主函数。
class TestArguments{
 public static void main(String[] args){
  for(String arg : args){
   System.out.println(arg);
  }
 }
}

练习：

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

public class ReflectTest2 {

 /**
  * @param args
  */
 public static void main(String[] args) throws Exception{
  // 将配置文件读取到流中
  InputStream ips = new FileInputStream("config.properties");

//将流中文件存入Properties集合中。

  Properties props = new Properties();
  props.load(ips);
  ips.close();
  String className = props.getProperty("className");

//建立集合对象，通过反射的构造方法。
  Collection collections = (Collection)Class.forName(className).newInstance();
  
  //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); 
  
  //pt1.y = 7;  
  //collections.remove(pt1);
  
  System.out.println(collections.size());
 }

}