Java反射机制深刻详解

时间  2019-12-07
标签 java 反射 机制 深刻 详解 栏目 Java 繁體版
原文   原文链接

一.概念

　　反射就是把Java的各类成分映射成相应的Java类。java

　　Class类的构造方法是private，由JVM建立。面试

　　反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查而且对内部的成员进行操做。例如它容许一个java的类获取他全部的成员变量和方法而且显示出来。Java 的这一能力在实际应用中也许用得不是不少，可是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中得到函数定义相关的信息。 （来自Sun）spring

　　JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操做软件组件。这些工具经过 reflection 动态的载入并取得 Java 组件(类) 的属性。数组

　　反射是从1.2就有的，后面的三大框架都会用到反射机制,涉及到类"Class",没法直接new CLass()，其对象是内存里的一份字节码.　　框架

　　Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每一个数组属于被映射为 Class 对象的一个类，全部具备相同元素类型和维数的数组都共享该 Class 对象。基本的 Java类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及经过调用类加载器中的 defineClass 方法自动构造的。　ide

1 Person p1 = new Person();
2 //下面的这三种方式均可以获得字节码
3 CLass c1 = Date.class();
4 p1.getClass(); 
5 //若存在则加载，不然新建,每每使用第三种,类的名字在写源程序时不须要知道，到运行时再传递过来
6 Class.forName("java.lang.String");

　　CLass.forName()字节码已经加载到java虚拟机中，去获得字节码；java虚拟机中尚未生成字节码 用类加载器进行加载，加载的字节码缓冲到虚拟机中。　函数

　　考虑下面这个简单的例子，让咱们看看 reflection 是如何工做的。工具

import java.lang.reflect.*;  

public class DumpMethods {  
   public static void main(String args[]) {  
      try {  
           Class c = Class.forName("java.util.Stack");  

           Method m[] = c.getDeclaredMethods();  
             
           for (int i = 0; i < m.length; i++)  
               System.out.println(m[i].toString());  
      }  
      catch (Throwable e){  
            System.err.println(e);  
      }  
   }  
}

 

1 public synchronized java.lang.Object java.util.Stack.pop() 
2 public java.lang.Object java.util.Stack.push(java.lang.Object) 
3 public boolean java.util.Stack.empty() 
4 public synchronized java.lang.Object java.util.Stack.peek() 
5 public synchronized int java.util.Stack.search(java.lang.Object)

　　这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类，而后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。ui

　　如下示例使用 Class 对象来显示对象的类名：this

1 void printClassName(Object obj) {
2          System.out.println("The class of " + obj +
3                             " is " + obj.getClass().getName());
4      }

　　还可使用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：

1 System.out.println("The name of class Foo is: "+Foo.class.getName());

 　　在没有对象实例的时候，主要有两种办法。

//得到类类型的两种方式        
Class cls1 = Role.class;        
Class cls2 = Class.forName("yui.Role");

　　注意第二种方式中，forName中的参数必定是完整的类名（包名+类名），而且这个方法须要捕获异常。如今获得cls1就能够建立一个Role类的实例了，利用Class的newInstance方法至关于调用类的默认的构造器。

1 Object o = cls1.newInstance(); 
2 //建立一个实例        
3 //Object o1 = new Role();   //与上面的方法等价

二.经常使用方法　　

　　1.isPrimitive(判断是不是基本类型的字节码)

public class TestReflect {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "abc";
        Class cls1 = str.getClass();
        Class cls2 = String.class;
        Class cls3 = null;//必需要加上null
        try {
            cls3 = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(cls1==cls2);
        System.out.println(cls1==cls3);
        
        System.out.println(cls1.isPrimitive());
        System.out.println(int.class.isPrimitive());//断定指定的 Class 对象是否表示一个基本类型。
        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());
    }
}
/*
 * true
true
false
true
false
true
false
true

 */
*/

　　2.getConstructor和getConstructors()

　　java中构造方法没有前后顺序，经过类型和参数个数区分。　

public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException {
        // TODO Auto-generated method stub
        String str = "abc";
        
        System.out.println(String.class.getConstructor(StringBuffer.class));
    }
}

　　3.Filed类表明某一类中的一个成员变量。

import java.lang.reflect.Field;
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        ReflectPointer rp1 = new ReflectPointer(3,4);
        Field fieldx = rp1.getClass().getField("x");//必须是x或者y
        System.out.println(fieldx.get(rp1));
        
        /*
         * private的成员变量必须使用getDeclaredField，并setAccessible(true),不然看获得拿不到
         */
        Field fieldy = rp1.getClass().getDeclaredField("y");
        fieldy.setAccessible(true);//暴力反射
        System.out.println(fieldy.get(rp1));
        
    }
}

class ReflectPointer {
    
    public int x = 0;
    private int y = 0;
    
    public ReflectPointer(int x,int y) {//alt + shift +s至关于右键source
        super();
        // TODO Auto-generated constructor stub
        this.x = x;
        this.y = y;
    }
}

三.典型例题

　　1.将全部String类型的成员变量里的b改为a。

import java.lang.reflect.Field;
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        ReflectPointer rp1 = new ReflectPointer(3,4);
        changeBtoA(rp1);
        System.out.println(rp1);
        
    }
    
    private static void changeBtoA(Object obj) throws RuntimeException, Exception {
        Field[] fields = obj.getClass().getFields();
        
        for(Field field : fields) {
            //if(field.getType().equals(String.class))
            //因为字节码只有一份,用equals语义不许确
            if(field.getType()==String.class) {
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replace('b', 'a');
                field.set(obj,newValue);
            }
        }
    }
}

class ReflectPointer {
    
    private int x = 0;
    public int y = 0;
    public String str1 = "ball";
    public String str2 = "basketball";
    public String str3 = "itcat";
    
    public ReflectPointer(int x,int y) {//alt + shift +s至关于右键source
        super();
        // TODO Auto-generated constructor stub
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="
                + str3 + "]";
    }
}

　　2.写一个程序根据用户提供的类名，调用该类的里的main方法。

　　为何要用反射的方式呢？

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        String str = args[0];
        /*
         * 这样会数组角标越界，由于压根没有这个字符数组
         * 须要右键在run as-configurations-arguments里输入b.Inter（完整类名）
         * 
         */
        Method m = Class.forName(str).getMethod("main",String[].class);
        //下面这两种方式均可以,main方法须要一个参数
        
        m.invoke(null, new Object[]{new String[]{"111","222","333"}});
        m.invoke(null, (Object)new String[]{"111","222","333"});//这个能够说明，数组也是Object
        /*
         * m.invoke(null, new String[]{"111","222","333"})
         * 上面的不能够,由于java会自动拆包
         */
    }
}

class Inter {
    public static void main(String[] args) {
        for(Object obj : args) {
            System.out.println(obj);
        }
    }
}

　　3.模拟 instanceof 操做符

class S {  
}   

public class IsInstance {  
   public static void main(String args[]) {  
      try {  
           Class cls = Class.forName("S");  
           boolean b1 = cls.isInstance(new Integer(37));  
           System.out.println(b1);  
           boolean b2 = cls.isInstance(new S());  
           System.out.println(b2);  
      }  
      catch (Throwable e) {  
           System.err.println(e);  
      }  
   }  
}

　　在这个例子中建立了一个S 类的 Class 对象，而后检查一些对象是不是S的实例。Integer(37) 不是，但 new S()是。

四.Method类

　　表明类（不是对象）中的某一方法。

import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*
 * 人在黑板上画圆，涉及三个对象,画圆须要圆心和半径，可是是私有的，画圆的方法
 * 分配给人不合适。
 * 
 * 司机踩刹车，司机只是给列车发出指令，刹车的动做还须要列车去完成。
 * 
 * 面试常常考面向对象的设计，好比人关门，人只是去推门。
 * 
 * 这就是专家模式：谁拥有数据，谁就是专家,方法就分配给谁
 */
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        String str = "shfsfs";
        //包开头是com表示是sun内部用的，java打头的才是用户的
        Method mtCharAt = String.class.getMethod("charAt", int.class);
        Object ch = mtCharAt.invoke(str,1);//若第一个参数是null，则确定是静态方法
        System.out.println(ch);
        
        System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4语法
        
    }
    
}

五.数组的反射

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

　　同类型同纬度有相同的字节码。

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

import java.util.Arrays;

/*
 * 从这个例子看出即使字节码相同可是对象也不必定相同,根本不是一回事
 * 
 */
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        int[] a = new int[3];
        int[] b = new int[]{4,5,5};//直接赋值后不能够指定长度，不然ＣＥ
        int[][] c = new int[3][2];
        String[] d = new String[]{"jjj","kkkk"};
        System.out.println(a==b);//false
        System.out.println(a.getClass()==b.getClass());//true
        //System.out.println(a.getClass()==d.getClass());    //比较字节码a和cd也无法比
        System.out.println(a.getClass());//输出class [I
        System.out.println(a.getClass().getName());//输出[I,中括号表示数组，I表示整数
        
        System.out.println(a.getClass().getSuperclass());//输出class java.lang.Object
        System.out.println(d.getClass().getSuperclass());//输出class java.lang.Object
        
        //因为父类都是Object,下面都是能够的
        Object obj1 = a;//不但是Object[]
        Object obj2 = b;
        Object[] obj3 = c;//基本类型的一位数组只能够当作Object，非得还能够当作Object[]
        Object obj4 = d;
        
        //注意asList处理int[]和String[]的区别
        System.out.println(Arrays.asList(b));//1.4没有可变参数，使用的是数组,[[I@1bc4459]
        System.out.println(Arrays.asList(d));//[jjj, kkkk]
        
    }
}

六.结束语

　　以上就是反射机制的简单的使用，显然学过spring的朋友必定明白了，为何能够经过配置文件就可让咱们得到指定的方法和变量，在咱们建立对象的时候都是经过传进string实现的，就好像你须要什么，咱们去为你生产，还有咱们一直在用Object,这就说明java语言的动态特性，依赖性大大的下降了。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程