java的反射机制

什么是反射

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

套用别人的一句话说，反射就是将java类中的各种成分映射成相应的java类。

反射的作用

   判断一个对象的类

  取出类的modifiers,数据成员,方法,构造器,和超类.运行时构造类的实例

  取得和设定对象数据成员的值。

  在运行时刻调用动态对象的方法。

   反射在框架里应用的很多，很多工具类底层也是反射机制实现的。如javaBean，自动调用get和set方法也是使用了反射/

反射的简单使用

下面是我最近复习反射机制的笔记

反射的包是java.lang.reflect。

下面是接下来测试需要用到的类：

package com.Howard.test02;

import java.io.Serializable;

/**
 * 用于java反射的测试类
 * @author Howard
 * 2017年2月17日
 */
public class PointTest implements Serializable{

     /**
      *
      */
     private static final long serialVersionUID = 1L;
     private int x;
     public int y;

     public String str_1 = "alibaba";
     public String str_2 = "basketball";
     public String str_3 = "tomorrow";

     public int getX() {
           return x;
     }
     public void setX(int x) {
           this.x = x;
     }
     public int getY() {
           return y;
     }
     public void setY(int y) {
           this.y = y;
     }
     public PointTest(int x, int y) {
           super();
           this.x = x;
           this.y = y;
     }
     public PointTest() {
           super();
     }
     @Override
     public String toString() {
           return "PointTest [x=" + x + ", y=" + y + ", str_1=" + str_1 + ", str_2=" + str_2 + ", str_3=" + str_3 + "]";
     }


}

反射获取包名和类名

（测试类的main方法调用我就省略了，以下同，代码有注释，我就不多写了）

 /**
      * 获取类名以及包名
      */
     public static void getNameAndPackage(){
           System.out.println(PointTest.class.getName());
           //com.Howard.test02.PointTest
     }

运行结果：

com.Howard.test02.PointTest

三种获取获取class字节码文件的方式

/**
      * 三种获取class字节码的方式
      * 相关比较
      * @throws ClassNotFoundException
      */
     public static void getClazz() throws ClassNotFoundException{
           Class<?> clazz_1 = PointTest.class;
           Class<?> clazz_2 = new PointTest().getClass();
           //抛ClassNotFoundException异常
           Class<?> clazz_3 = Class.forName("com.Howard.test02.PointTest");

           System.out.println(clazz_1.getName());
           System.out.println(clazz_2.getName());
           System.out.println(clazz_3.getName());

           //比较
           System.out.println(clazz_1 == clazz_2);
           System.out.println(clazz_2 == clazz_3);

           String s = "abc";
           //isPrimitive()是否为基本类型
           System.out.println("string是否为基本类型:"+s.getClass().isPrimitive());

           System.out.println(int.class == Integer.class);
           System.out.println(int.class == Integer.TYPE);
           System.out.println("int是否为基本类型:"+int.class.isPrimitive());
           System.out.println("int[]是否为基本类型:"+int[].class.isPrimitive());
           System.out.println("int[]是否为数组:"+int[].class.isArray());


     }

运行结果：

获取父类以及实现的接口

 /**
      * 获取父类以及接口
      * @throws Exception
      */
     public static void getSuperClass() throws Exception{
           Class<?> clazz = Class.forName("com.Howard.test02.PointTest");

           //获取父类
           Class<?> superclass = clazz.getSuperclass();

           Class<?>[] interfaces = clazz.getInterfaces();

           System.out.println("父类："+superclass.getName());
           System.out.println("实现的接口：");
           for(int i = 0;i<interfaces.length;i++){
                System.out.println(interfaces[i]+" ");
           }


           /*
           父类：java.lang.Object
                         实现的接口：
        interface java.io.Serializable
            */

     }

运行结果：

获取构造方法以及利用构造方法实例化对象

 /**
      * 获取构造方法并通过构造方法new出实例对象
      * @throws Exception
      */
     public static void getConstructor() throws Exception{
           //String str = new String("abc");
           //传入参数类型
           Constructor<String> constructor_1 = String.class.getConstructor(StringBuffer.class);
           //通过构造器来实例化对象
           //如果上面得到的Constructor没有明确泛型，下面就必须强制转换
           //参数必须明确new出类型 直接用字符串是会报argument type mismatch异常
           String str = constructor_1.newInstance(new StringBuffer("abc"));
           System.out.println(str.charAt(2));
     }

运行结果：

获取成员变量

 /**
      * 获取成员变量Field
      * 注意private的获取方式
      * @throws Exception
      */
     public static void getField() throws Exception{
           PointTest poit = new PointTest(5, 7);

           Field fieldY = poit.getClass().getField("y");
           //这时得到的fieldY只是一个变量 并不能说它的值为5
           System.out.println(fieldY);
           System.out.println(fieldY.getType());
           //得到值必须指定哪个具体对象
           System.out.println(fieldY.get(poit));
           System.out.println(fieldY.getInt(poit));
           //使用下面的方法获取private的变量x，会认为看不到这个变量 在获取具体信息时会报java.lang.NoSuchFieldException: x
//         Field fieldX = poit.getClass().getField("x");

           Field fieldX = poit.getClass().getDeclaredField("x");
           //获取权限修饰符
           int a = fieldX.getModifiers();
           System.out.println(Modifier.toString(a));

           //使用getDeclaredField获取x后，在获取值时仍会报xxx with modifiers "private"
           //private 无访问权限 所以通过下面的方法先强制访问
           fieldX.setAccessible(true);

           System.out.println(fieldX.getType());
           System.out.println(fieldX.get(poit));

     }

运行结果：

获取类的方法method

/**
      * 获取方法method并执行
      * @throws Exception
      */
     public static void getMethod() throws Exception{
           //反射实现如下语句
//         String str = "abc";
//         str.charAt(2);

           String str = "abc";
           //第一个参数 方法名 第2~n个参数 参数类型
           Method methodCharAt = String.class.getMethod("charAt", int.class);
           System.out.println(methodCharAt.invoke(str, 2));
           System.out.println(methodCharAt.invoke(str, new Object[]{2}));
     }

运行结果：

获取main方法并执行

这里我另创建一个类，含有main方法。

package com.Howard.test02;
/**
 * 用于反射测试主函数
 * @author Howard
 * 2017年2月17日
 */
public class ArgumentsTest {

     public static void main(String[] args) {
           System.out.println("test!!!!");
           if(args.length>0){
                System.out.println(args[0]);
           }
     }

}

下面的方法就是用于通过反射获取上面类的方法并进行相关操作

/**
      * 获取com.Howard.test02.ArgumentsTest的main方法并传参数执行
      * @throws Exception
      */
     public static void TestMain() throws Exception{
           ArgumentsTest.main(new String[]{});

           System.out.println(ArgumentsTest.class.getName());

           Method method = ArgumentsTest.class.getMethod("main", String[].class);
           //下面的参数这样写会报错java.lang.NoSuchMethodException
           //因为jdk会自动拆箱为多个参数，但是该方法只要一个数组参数
           //method.invoke(null, new String[]{"123","234"});

           //下面这样写会把参数包成一个数组
           method.invoke(null, new Object[]{new String[]{"123","234"}});
           method.invoke(null, (Object)new String[]{"123","234"});

     }

运行结果：

数组的反射以及数组与Object的关系

 /**
      * 数组与Object的关系以及数组的反射
      */
     public static void testArray(){
           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","d"};
           System.out.println(a1.getClass() == a2.getClass());
           //下面三者无法比较
//         System.out.println(a2.getClass() == a3.getClass());
//         System.out.println(a3.getClass() == a4.getClass());
//         System.out.println(a4.getClass() == a1.getClass());

           //[I  [表示数组 I表示int
           System.out.println(a1.getClass().getName());
           System.out.println(a3.getClass().getName());
          System.out.println(a1.getClass().getSuperclass().getName());
          System.out.println(a2.getClass().getSuperclass().getName());

           //引伸
           Object aObj1 = a1;
           Object aObj2 = a4;
           Object aObj3 = a3;
           //下面这个编译就过不去
//         Object[] aObj4 = a1;
           Object[] aObj5 = a3;
           Object[] aObj6 = a4;

           //下面的结果是：
           //[I@15db9742
           //[Ljava.lang.String;@6d06d69c
           System.out.println(a1);
           System.out.println(a4);

           //如果想看到数组里面的具体值。使用arrays工具类：
           //结果：
           //[[I@15db9742]
           //[a, b, c, d]
           //asList接收的是T...a
           //根据上面Object测试结果int数组是被当作Object的，而string数组可以被当作Object数组的，所以会有下面的结果
           System.out.println(Arrays.asList(a1));
           System.out.println(Arrays.asList(a4));

     }

运行结果：

反射的简单应用

1、将字符串中所有的b改为z

/**
      * 练习
      * 将PointTest中string类型的值中b改为z
      * @throws Exception
      */
     public static void practiceChangeString() throws Exception{
           PointTest poit = new PointTest();

           System.out.println("old:"+poit);

           //获取所有成员变量
           Field[] fields = poit.getClass().getDeclaredFields();
           for(Field field:fields){
                //字节码比较 用==
                if(field.getType() == String.class){
                     String oldvalue =(String)field.get(poit);
                     String newvalue = oldvalue.replace("b", "z");
                     field.set(poit, newvalue);
                }
           }

           System.out.println("new:"+poit);
     }

运行结果：

2、反射判断是否为数组，如果是 输出数组各个值

 /**
      * 数组反射 获取类并判断是否为数组 如果是 输出各个数
      * @param obj
      */
     public static void practiceArray(Object obj){
           Class clazz = obj.getClass();
           System.out.println(clazz.getName());
           if(clazz.isArray()){
                System.out.println(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);
           }
     }

这里有必要说下我main调用传的参数：

practiceArray("abc");
practiceArray(new String[]{"1","2","3"});

运行结果：