做者 | 火星十一郎java
来源 | https://www.cnblogs.com/hxsylweb
一.概念面试
反射就是把Java的各类成分映射成相应的Java类。spring
反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查而且对内部的成员进行操做。例如它容许一个java的类获取他全部的成员变量和方法而且显示出来。Java 的这一能力在实际应用中也许用得不是不少，可是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中得到函数定义相关的信息。（来自Sun）微信
JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操做软件组件。这些工具经过 reflection 动态的载入并取得 Java 组件(类) 的属性。架构
反射是从1.2就有的，后面的三大框架都会用到反射机制,涉及到类"Class",没法直接new CLass()，其对象是内存里的一份字节码. app
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虚拟机中尚未生成字节码 用类加载器进行加载，加载的字节码缓冲到虚拟机中。
另外，你们能够关注微信公众号Java技术栈回复：JVM，获取我整理的系列JVM教程，都是干货。
考虑下面这个简单的例子，让咱们看看 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());
}
}
结果：
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()是。
推荐阅读：instanceof、isInstance、isAssignableFrom
四.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语言的动态特性，依赖性大大的下降了。
本文版权归做者火星十一郎全部，欢迎转载和商用，但未经做者赞成必须保留此段声明，且在文章页面明显位置给出原文链接，不然保留追究法律责任的权利.
欢迎进入架构师智库，作有来领导力的架构师
本文分享自微信公众号 - 架构师智库（beijing-tmt）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。