Java Reflect(反射)機制詳解
反射機制是在運作狀态中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意一個方法和屬性；這種動态擷取的資訊以及動态調用對象的方法的功能稱為java語言的反射機制。
反射機制主要提供了以下功能：
-在運作時判斷任意一個對象所屬的類；
-在運作時構造任意一個類的對象；
-在運作時判斷任意一個類所具有的成員變量和方法；
-在運作時調用任意一個對象的方法；
-生成動态代理。
反射機制的相關API
通過一個對象獲得完整的包名和類名
/**
* 獲得完整的包名和類名
* @author mazaiting
*/
public class Reflect1 {
public static void main(String[] args) {
Reflect1 reflect1 = new Reflect1();
System.out.println("包名: " + reflect1.getClass().getPackage());
System.out.println("類名: " + reflect1.getClass().getName());
System.out.println("簡單名: " + reflect1.getClass().getSimpleName());
System.out.println("規範名: " + reflect1.getClass().getCanonicalName());
System.out.println("類型名: " + reflect1.getClass().getTypeName());
/**
* 包名: package com.mazaiting
* 類名: com.mazaiting.Reflect1
* 簡單名: Reflect1
* 規範名: com.mazaiting.Reflect1
* 類型名: com.mazaiting.Reflect1
*/
}
}
執行個體化Class類對象
/**
* 執行個體化Class類對象
* @author mazaiting
*/
public class Reflect2 {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> class1 = null;
Class<?> class2 = null;
Class<?> class3 = null;
class1 = Class.forName("com.mazaiting.Reflect2");
class2 = new Reflect2().getClass();
class3 = Reflect2.class;
System.out.println("類名: " + class1.getName());
System.out.println("類名: " + class2.getName());
System.out.println("類名: " + class3.getName());
/**
* 類名: com.mazaiting.Reflect2
* 類名: com.mazaiting.Reflect2
* 類名: com.mazaiting.Reflect2
*/
}
}
擷取一個對象的父類與實作的接口
/**
* 擷取一個對象的父類與實作的接口
* @author mazaiting
*/
public class Reflect3 implements Serializable{
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.mazaiting.Reflect3");
Class<?> superclass = clazz.getSuperclass();
System.out.println("clazz的父類: " + superclass.getName());
Class<?>[] interfaces = clazz.getInterfaces();
for (int i = 0; i < interfaces.length; i++){
System.out.println("接口" + i + ": " + interfaces[i].getName());
}
/**
* clazz的父類: java.lang.Object
* 接口0: java.io.Serializable
*/
}
}
擷取某個類中的全部構造函數
/**
* 擷取某個類中的全部構造函數
* 通過反射機制執行個體化一個類的對象
* @author mazaiting
*/
public class Reflect4 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
Class<?> clazz = Class.forName("com.mazaiting.User");
Constructor<?>[] constructors = clazz.getConstructors();
System.out.println("構造方法共 " + constructors.length + "個");
for (int i=0;i<constructors.length; i++){
Class<?>[] parameterTypes = constructors[i].getParameterTypes();
System.out.print("cons[" + i + "] (");
for (int j=0; j<parameterTypes.length; j++){
if (j == parameterTypes.length - 1)
System.out.print(parameterTypes[j].getName());
else
System.out.print(parameterTypes[j].getName() + ",");
}
System.out.println(")");
}
/**
* 構造方法共 3個
* cons[0] (java.lang.String,int)
* cons[1] (java.lang.String)
* cons[2] ()
*/
User user0 = (User) constructors[0].newInstance("mazaiting", 23);
System.out.println(user0.toString());
User user1 = (User) constructors[1].newInstance("mazaiting");
System.out.println(user1.toString());
User user2 = (User) constructors[2].newInstance();
System.out.println(user2.toString());
/**
* User [name=mazaiting, age=23]
* User [name=mazaiting, age=0]
* User [name=null, age=0]
*/
}
}
public class User {
private String name;
private int age;
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
public User(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
擷取某個類的全部屬性
/**
* 擷取某個類的全部屬性
* @author mazaiting
*/
public class Reflect5 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
Class<?> clazz = Class.forName("com.mazaiting.Reflect5");
System.out.println("===============本類屬性===============");
// 取得本類的全部屬性
Field[] fields = clazz.getDeclaredFields();
for(int i=0;i<fields.length; i++){
// 權限修飾
int modifiers = fields[i].getModifiers();
String mo = Modifier.toString(modifiers);
// 屬性類型
Class<?> type = fields[i].getType();
System.out.println(mo + " " + type.getName() + " " + fields[i].getName() + ";");
}
System.out.println("==========實作的接口或者父類的屬性==========");
// 取得實作的接口或者父類的屬性
Field[] fields2 = clazz.getFields();
for(int i=0;i<fields2.length;i++){
int modifiers = fields2[i].getModifiers();
String mo = Modifier.toString(modifiers);
Class<?> type = fields2[i].getType();
System.out.println(mo + " " + type.getName() + " " + fields2[i].getName() + ";");
}
/**
* ===============本類屬性===============
* private static final long serialVersionUID;
* ==========實作的接口或者父類的屬性==========
*
*/
}
}
擷取某個類的全部方法
/**
* 擷取某個類的全部方法
* @author mazaiting
*/
public class Reflect6 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.mazaiting.User");
// 擷取與父類的全部方法，如果要擷取目前類的方法所有方法
// 則使用clazz.getDeclaredMethods()方法
Method[] methods = clazz.getMethods();
for(int i=0;i<methods.length;i++){
// 傳回類型
Class<?> returnType = methods[i].getReturnType();
int modifiers = methods[i].getModifiers();
// 權限修飾符
String modifier = Modifier.toString(modifiers);
Class<?>[] parameterTypes = methods[i].getParameterTypes();
Class<?>[] exceptionTypes = methods[i].getExceptionTypes();
System.out.println("函數名: " + methods[i].getName());
System.out.println("權限修飾: " + modifier);
System.out.println("傳回值: " + returnType.getName());
System.out.println("參數個數: " + parameterTypes.length);
System.out.println("異常個數: " + exceptionTypes.length);
System.out.println("---------------------------------------");
}
/**
* 函數名: toString
* 權限修飾: public
* 傳回值: java.lang.String
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
* 函數名: getName
* 權限修飾: public
* 傳回值: java.lang.String
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
* 函數名: setName
* 權限修飾: public
* 傳回值: void
* 參數個數: 1
* 異常個數: 0
* ---------------------------------------
* 函數名: getAge
* 權限修飾: public
* 傳回值: int
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
* 函數名: setAge
* 權限修飾: public
* 傳回值: void
* 參數個數: 1
* 異常個數: 0
* ---------------------------------------
* 函數名: wait
* 權限修飾: public final
* 傳回值: void
* 參數個數: 0
* 異常個數: 1
* ---------------------------------------
* 函數名: wait
* 權限修飾: public final
* 傳回值: void
* 參數個數: 2
* 異常個數: 1
* ---------------------------------------
* 函數名: wait
* 權限修飾: public final native
* 傳回值: void
* 參數個數: 1
* 異常個數: 1
* ---------------------------------------
* 函數名: equals
* 權限修飾: public
* 傳回值: boolean
* 參數個數: 1
* 異常個數: 0
* ---------------------------------------
* 函數名: hashCode
* 權限修飾: public native
* 傳回值: int
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
* 函數名: getClass
* 權限修飾: public final native
* 傳回值: java.lang.Class
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
* 函數名: notify
* 權限修飾: public final native
* 傳回值: void
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
* 函數名: notifyAll
* 權限修飾: public final native
* 傳回值: void
* 參數個數: 0
* 異常個數: 0
* ---------------------------------------
*/
}
}
通過反射機制調用某個類的方法
/**
* 反射機制調用某個類的方法
* @author mazaiting
*/
public class Reflect7 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
Class<?> clazz = Class.forName("com.mazaiting.Reflect7");
// 擷取目前類的reflect1方法
Method reflect1 = clazz.getDeclaredMethod("reflect1");
// 執行方法
reflect1.invoke(clazz.newInstance());
Method reflect2 = clazz.getDeclaredMethod("reflect2", int.class, String.class);
reflect2.invoke(clazz.newInstance(), 20, "mazaiting");
/**
* Java 反射機制 - 調用某個類的方法1.
* Java 反射機制 - 調用某個類的方法2.
* age -> 20. name -> mazaiting
*/
}
public void reflect1() {
System.out.println("Java 反射機制 - 調用某個類的方法1.");
}
public void reflect2(int age, String name) {
System.out.println("Java 反射機制 - 調用某個類的方法2.");
System.out.println("age -> " + age + ". name -> " + name);
}
}
通過反射機制操作某個類的屬性
/**
* 反射機制更改屬性值
* @author mazaiting
*/
public class Reflect8 implements Serializable{
private static final long serialVersionUID = -2862585049955236662L;
private String proprety = null;
public static void main(String[] args) throws Exception{
// 擷取類
Class<?> clazz = Class.forName("com.mazaiting.Reflect8");
// 得到目前類的執行個體
Reflect8 instance = (Reflect8) clazz.newInstance();
// 擷取要更改的屬性
Field proprety = clazz.getDeclaredField("proprety");
// 設定可通路
proprety.setAccessible(true);
// 設定屬性
proprety.set(instance, "屬性");
System.out.println(proprety.get(instance));
/**
* 屬性
*/
}
}
反射機制的動态代理
/**
* 反射機制的動态代理
* 在java中有三種類類加載器。
* 1) Bootstrap ClassLoader 此加載器采用c++編寫，一般開發中很少見。
* 2) Extension ClassLoader 用來進行擴充類的加載，一般對應的是jrelibext目錄中的類
* 3) AppClassLoader 加載classpath指定的類，是最常用的加載器。同時也是java中預設的加載器。
* 如果想要完成動态代理，首先需要定義一個InvocationHandler接口的子類，已完成代理的具體操作。
* @author mazaiting
*/
public class Reflect9 {
public static void main(String[] args) throws Exception{
MyInvocationHandler invocationHandler = new MyInvocationHandler();
Subject sub = (Subject) invocationHandler.bind(new RealSubject());
String info = sub.say("mazaiting", 23);
System.out.println(info);
/**
* mazaiting, 23
*/
}
}
class MyInvocationHandler implements InvocationHandler{
private Object obj = null;
public Object bind(Object obj) {
this.obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object temp = method.invoke(obj, args);
return temp;
}
}
class RealSubject implements Subject{
@Override
public String say(String name, int age) {
return name + ", " + age;
}
}
interface Subject{
String say(String name, int age);
}
執行個體
在泛型為Integer的ArrayList中存放一個String類型的對象。
/**
* 在泛型為Integer的ArrayList中存放一個String類型的對象。
* @author mazaiting
*/
public class Reflect10 {
public static void main(String[] args) throws Exception{
ArrayList<Integer> list = new ArrayList<>();
Method method = list.getClass().getDeclaredMethod("add", Object.class);
method.invoke(list, "Java反射機制執行個體");
System.out.println(list.get(0));
/**
* Java反射機制執行個體
*/
}
}
通過反射取得并修改數組的資訊
/**
* 反射取得并修改數組的資訊
* @author mazaiting
*/
public class Reflect11 {
public static void main(String[] args) throws Exception{
int[] temp = {1, 2, 3, 4, 5};
Class<?> componentType = temp.getClass().getComponentType();
System.out.println("數組類型: " + componentType.getName());
System.out.println("數組長度: " + Array.getLength(temp));
System.out.println("數組的第一個元素: " + Array.get(temp, 0));
// 設定第一個元素資料為100
Array.set(temp, 0, 100);
System.out.println("修改之後數組第一個元素為： " + Array.get(temp, 0));
}
}
通過反射機制修改數組的大小
/**
* 反射機制修改數組的大小
* @author mazaiting
*/
public class Reflect12 {
public static void main(String[] args) throws Exception {
int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int[] newTemp = (int[]) arrayInc(temp, 15);
print(newTemp);
String[] atr = { "a", "b", "c" };
String[] str1 = (String[]) arrayInc(atr, 8);
print(str1);
/**
* 數組長度為： 15
* 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0
* 數組長度為： 8
* a b c null null null null null
*/
}
// 修改數組大小
public static Object arrayInc(Object obj, int len) {
Class<?> arr = obj.getClass().getComponentType();
Object newArr = Array.newInstance(arr, len);
int co = Array.getLength(obj);
System.arraycopy(obj, 0, newArr, 0, co);
return newArr;
}
// 列印
public static void print(Object obj) {
Class<?> c = obj.getClass();
if (!c.isArray()) {
return;
}
System.out.println("數組長度為： " + Array.getLength(obj));
for (int i = 0; i < Array.getLength(obj); i++) {
System.out.print(Array.get(obj, i) + " ");
}
System.out.println();
}
}
将反射機制應用于工廠模式
/**
* 反射機制應用于工廠模式
* @author mazaiting
*/
public class Reflect13 {
public static void main(String[] args) throws Exception {
// Fruit f = Factory.getInstance("com.mazaiting.Orange");
Fruit f = Factory.getInstance("com.mazaiting.Apple");
if (f != null) {
f.eat();
}
/**
* Apple
*/
}
}
interface Fruit {
public abstract void eat();
}
class Apple implements Fruit {
public void eat() {
System.out.println("Apple");
}
}
class Orange implements Fruit {
public void eat() {
System.out.println("Orange");
}
}
class Factory {
public static Fruit getInstance(String ClassName) {
Fruit f = null;
try {
f = (Fruit) Class.forName(ClassName).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
![Java String.format方法的簡單使用[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)