一、定义

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 }