一.概念
反射就是把Java的各种成分映射成相应的Java类。
Class类的构造方法是private，由JVM创立。
反射是java语言的一个个性，它允程序在运行时（留神不是编译的时候）来进行自我查看并且对外部的成员进行操作。例如它容许一个java的类获取他所有的成员变量和办法并且显示进去。Java 的这一能力在理论利用中兴许用得不是很多，然而在其它的程序设计语言中基本就不存在这一个性。例如，Pascal、C 或者 C++ 中就没有方法在程序中取得函数定义相干的信息。（来自Sun）
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 办法主动结构的。
Person p1 = new Person();//上面的这三种形式都能够失去字节码CLass c1 = Date.class();p1.getClass();//若存在则加载，否则新建,往往应用第三种,类的名字在写源程序时不须要晓得，到运行时再传递过去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); } }}public synchronized java.lang.Object java.util.Stack.pop()public java.lang.Object java.util.Stack.push(java.lang.Object)public boolean java.util.Stack.empty()public synchronized java.lang.Object java.util.Stack.peek()public synchronized int java.util.Stack.search(java.lang.Object) 这样就列出了java.util.Stack 类的各办法名以及它们的限制符和返回类型。这个程序应用 Class.forName 载入指定的类，而后调用 getDeclaredMethods 来获取这个类中定义了的办法列表。java.lang.reflect.Methods 是用来形容某个类中单个办法的一个类。
以下示例应用 Class 对象来显示对象的类名：
void printClassName(Object obj) { System.out.println("The class of " + obj + " is " + obj.getClass().getName());} 还能够应用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：
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办法相当于调用类的默认的结构器。
Object o = cls1.newInstance();//创立一个实例//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()); }} 后果：
truetruefalsetruefalsetruefalsetrue 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语言的动静个性，依赖性大大的升高了。
起源：cnblogs.com/hxsyl
欢送关注我的微信公众号「码农解围」，分享Python、Java、大数据、机器学习、人工智能等技术，关注码农技术晋升•职场解围•思维跃迁，20万+码农成长充电第一站，陪有幻想的你一起成长