一、定義

JAVA反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意方法和屬性；這種動態獲取資訊以及動態呼叫物件方法的功能稱為java語言的反射機制。

反射應該是 JVM讀取相應類的 位元組碼檔案

二、用途

在日常的第三方應用開發過程中，經常會遇到某個類的某個成員變數、方法或是屬性是私有的或是隻對系統應用開放，這時候就可以利用Java的反射機制通過反射來獲取所需的私有成員或是方法。

Java反射機制主要提供了以下功能：

• 在執行時判斷任意一個物件所屬的類。
• 在執行時構造任意一個類的物件。
• 在執行時判斷任意一個類所具有的成員變數和方法。
• 在執行時呼叫任意一個物件的方法。
• 生成動態代理。

三、反射機制的相關類

與Java反射相關的類如下：

3.1 Class類

Class代表類的實體，在執行的Java應用程式中表示類和介面。在這個類中提供了很多有用的方法，這裡對他們簡單的分類介紹。

• 獲得類相關的方法

• 獲得類中屬性相關的方法

• 獲得類中註解相關的方法

• 獲得類中構造器相關的方法

• 獲得類中方法相關的方法

• 類中其他重要的方法

3.2 Field類

Field代表類的成員變數（成員變數也稱為類的屬性）。

3.3 Method類

Method代表類的方法。

3.4 Constructor類

Constructor代表類的構造方法。

示例

• 被反射類Book.java

 1 public class Book{
 2     private final static String TAG = "BookTag";
 3 
 4     private String name;
 5     private String author;
 6 
 7     @Override
 8     public String toString() {
 9         return "Book{" +
10                 "name='" + name + '\'' +
11                 ", author='" + author + '\'' +
12                 '}';
13     }
14 
15     public Book() {
16     }
17 
18     private Book(String name, String author) {
19         this.name = name;
20         this.author = author;
21     }
22 
23     public String getName() {
24         return name;
25     }
26 
27     public void setName(String name) {
28         this.name = name;
29     }
30 
31     public String getAuthor() {
32         return author;
33     }
34 
35     public void setAuthor(String author) {
36         this.author = author;
37     }
38 
39     private String declaredMethod(int index) {
40         String string = null;
41         switch (index) {
42             case 0:
43                 string = "I am declaredMethod 1 !";
44                 break;
45             case 1:
46                 string = "I am declaredMethod 2 !";
47                 break;
48             default:
49                 string = "I am declaredMethod 1 !";
50         }
51 
52         return string;
53     }
54 }

• 反射邏輯封裝在ReflectClass.java

  1 public class ReflectClass {
  2     private final static String TAG = "peter.log.ReflectClass";
  3 
  4     // 建立物件
  5     public static void reflectNewInstance() {
  6         try {
  7             Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
  8             Object objectBook = classBook.newInstance();
  9             Book book = (Book) objectBook;
 10             book.setName("Android進階之光");
 11             book.setAuthor("劉望舒");
 12             Log.d(TAG,"reflectNewInstance book = " + book.toString());
 13         } catch (Exception ex) {
 14             ex.printStackTrace();
 15         }
 16     }
 17 
 18     // 反射私有的構造方法
 19     public static void reflectPrivateConstructor() {
 20         try {
 21             Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
 22             Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class,String.class);
 23             declaredConstructorBook.setAccessible(true);
 24             Object objectBook = declaredConstructorBook.newInstance("Android開發藝術探索","任玉剛");
 25             Book book = (Book) objectBook;
 26             Log.d(TAG,"reflectPrivateConstructor book = " + book.toString());
 27         } catch (Exception ex) {
 28             ex.printStackTrace();
 29         }
 30     }
 31 
 32     // 反射私有屬性
 33     public static void reflectPrivateField() {
 34         try {
 35             Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
 36             Object objectBook = classBook.newInstance();
 37             Field fieldTag = classBook.getDeclaredField("TAG");
 38             fieldTag.setAccessible(true);
 39             String tag = (String) fieldTag.get(objectBook);
 40             Log.d(TAG,"reflectPrivateField tag = " + tag);
 41         } catch (Exception ex) {
 42             ex.printStackTrace();
 43         }
 44     }
 45 
 46     // 反射私有方法
 47     public static void reflectPrivateMethod() {
 48         try {
 49             Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
 50             Method methodBook = classBook.getDeclaredMethod("declaredMethod",int.class);
 51             methodBook.setAccessible(true);
 52             Object objectBook = classBook.newInstance();
 53             String string = (String) methodBook.invoke(objectBook,0);
 54 
 55             Log.d(TAG,"reflectPrivateMethod string = " + string);
 56         } catch (Exception ex) {
 57             ex.printStackTrace();
 58         }
 59     }
 60 
 61     // 獲得系統Zenmode值
 62     public static int getZenMode() {
 63         int zenMode = -1;
 64         try {
 65             Class<?> cServiceManager = Class.forName("android.os.ServiceManager");
 66             Method mGetService = cServiceManager.getMethod("getService", String.class);
 67             Object oNotificationManagerService = mGetService.invoke(null, Context.NOTIFICATION_SERVICE);
 68             Class<?> cINotificationManagerStub = Class.forName("android.app.INotificationManager$Stub");
 69             Method mAsInterface = cINotificationManagerStub.getMethod("asInterface",IBinder.class);
 70             Object oINotificationManager = mAsInterface.invoke(null,oNotificationManagerService);
 71             Method mGetZenMode = cINotificationManagerStub.getMethod("getZenMode");
 72             zenMode = (int) mGetZenMode.invoke(oINotificationManager);
 73         } catch (Exception ex) {
 74             ex.printStackTrace();
 75         }
 76 
 77         return zenMode;
 78     }
 79 
 80     // 關閉手機
 81     public static void shutDown() {
 82         try {
 83             Class<?> cServiceManager = Class.forName("android.os.ServiceManager");
 84             Method mGetService = cServiceManager.getMethod("getService",String.class);
 85             Object oPowerManagerService = mGetService.invoke(null,Context.POWER_SERVICE);
 86             Class<?> cIPowerManagerStub = Class.forName("android.os.IPowerManager$Stub");
 87             Method mShutdown = cIPowerManagerStub.getMethod("shutdown",boolean.class,String.class,boolean.class);
 88             Method mAsInterface = cIPowerManagerStub.getMethod("asInterface",IBinder.class);
 89             Object oIPowerManager = mAsInterface.invoke(null,oPowerManagerService);
 90             mShutdown.invoke(oIPowerManager,true,null,true);
 91 
 92         } catch (Exception ex) {
 93             ex.printStackTrace();
 94         }
 95     }
 96 
 97     public static void shutdownOrReboot(final boolean shutdown, final boolean confirm) {
 98         try {
 99             Class<?> ServiceManager = Class.forName("android.os.ServiceManager");
100             // 獲得ServiceManager的getService方法
101             Method getService = ServiceManager.getMethod("getService", java.lang.String.class);
102             // 呼叫getService獲取RemoteService
103             Object oRemoteService = getService.invoke(null, Context.POWER_SERVICE);
104             // 獲得IPowerManager.Stub類
105             Class<?> cStub = Class.forName("android.os.IPowerManager$Stub");
106             // 獲得asInterface方法
107             Method asInterface = cStub.getMethod("asInterface", android.os.IBinder.class);
108             // 呼叫asInterface方法獲取IPowerManager物件
109             Object oIPowerManager = asInterface.invoke(null, oRemoteService);
110             if (shutdown) {
111                 // 獲得shutdown()方法
112                 Method shutdownMethod = oIPowerManager.getClass().getMethod(
113                         "shutdown", boolean.class, String.class, boolean.class);
114                 // 呼叫shutdown()方法
115                 shutdownMethod.invoke(oIPowerManager, confirm, null, false);
116             } else {
117                 // 獲得reboot()方法
118                 Method rebootMethod = oIPowerManager.getClass().getMethod("reboot",
119                         boolean.class, String.class, boolean.class);
120                 // 呼叫reboot()方法
121                 rebootMethod.invoke(oIPowerManager, confirm, null, false);
122             }
123         } catch (Exception e) {
124             e.printStackTrace();
125         }
126     }
127 }