共计 7889 个字符，预计需要花费 20 分钟才能阅读完成。
一. 概念
反射就是把 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());
}
} 后果：
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};// 间接赋值后不能够指定长度，否则CE
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 万 + 码农成长充电第一站，陪有幻想的你一起成长