java高级特性---反射机制详解

墨蓝 2022-12-30 07:42 174阅读 0赞

### 反射机制： ###

javai反'z射机h制是在运机制行状态中，对于任意一个类，都能够知道这个类的所有属性和方法 ；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

简单来说，能够分析类能力的程序称为反射。

### 反射的功能： ###

*  在运行时判断任意一个对象所属的类
 *  在运行时构造任意一个类的对象
 *  在运行时判断任意一个类所具有的成员变量和方法
 *  在运行时调用任意一个对象的方法
 *  生成动态代理

### 反射的用途： ###

在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用java反射机制通过反射来获取所需的私有成员或是方法。当然，也不是所有的都适合反射，对于没有权限的应用返回值是没有意义的缺省值，否则返回实际值，起到保护用户隐私的目的。

### 反射机制相关类： ###

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Class</td> 
   <td>反射的核心类，可以获取类的属性，方法等信息</td> 
  </tr> 
  <tr> 
   <td>Field</td> 
   <td>java.lang.reflec包中的类，表示类成员变量，可以用来获取和设置类中的属性值</td> 
  </tr> 
  <tr> 
   <td>Method</td> 
   <td>java.lang.reflec包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法</td> 
  </tr> 
  <tr> 
   <td>Constructor</td> 
   <td>java.lang.reflec包中的类，表示类的构造方法</td> 
  </tr> 
 </tbody> 
</table>

### 反射的使用： ###

首先构造一个与书籍相关的model---Book.java，然后通过反射方法示例创建对象、反射私有构造方法、反射私有属性、反射私有私有方法。

**被反射的类：Book.java**

public class Book{
        private final static String TAG = "BookTag";
    
        private String name;
        private String author;
    
        @Override
        public String toString() {
            return "Book{" +
                    "name='" + name + '\'' +
                    ", author='" + author + '\'' +
                    '}';
        }
    
        public Book() {
        }
    
        private Book(String name, String author) {
            this.name = name;
            this.author = author;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        private String declaredMethod(int index) {
            String string = null;
            switch (index) {
                case 0:
                    string = "I am declaredMethod 1 !";
                    break;
                case 1:
                    string = "I am declaredMethod 2 !";
                    break;
                default:
                    string = "I am declaredMethod 1 !";
            }
    
            return string;
        }
    }

### 反射逻辑： ###

public class ReflectClass {
        private final static String TAG = "peter.log.ReflectClass";
    
        // 创建对象
        public static void reflectNewInstance() {
            try {
                Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
                Object objectBook = classBook.newInstance();
                Book book = (Book) objectBook;
                book.setName("Android进阶之光");
                book.setAuthor("刘望舒");
                Log.d(TAG,"reflectNewInstance book = " + book.toString());
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    
        // 反射私有的构造方法
        public static void reflectPrivateConstructor() {
            try {
                Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
                Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class,String.class);
                declaredConstructorBook.setAccessible(true);
                Object objectBook = declaredConstructorBook.newInstance("Android开发艺术探索","任玉刚");
                Book book = (Book) objectBook;
                Log.d(TAG,"reflectPrivateConstructor book = " + book.toString());
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    
        // 反射私有属性
        public static void reflectPrivateField() {
            try {
                Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
                Object objectBook = classBook.newInstance();
                Field fieldTag = classBook.getDeclaredField("TAG");
                fieldTag.setAccessible(true);
                String tag = (String) fieldTag.get(objectBook);
                Log.d(TAG,"reflectPrivateField tag = " + tag);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    
        // 反射私有方法
        public static void reflectPrivateMethod() {
            try {
                Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");
                Method methodBook = classBook.getDeclaredMethod("declaredMethod",int.class);
                methodBook.setAccessible(true);
                Object objectBook = classBook.newInstance();
                String string = (String) methodBook.invoke(objectBook,0);
    
                Log.d(TAG,"reflectPrivateMethod string = " + string);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    
        // 获得系统Zenmode值
        public static int getZenMode() {
            int zenMode = -1;
            try {
                Class<?> cServiceManager = Class.forName("android.os.ServiceManager");
                Method mGetService = cServiceManager.getMethod("getService", String.class);
                Object oNotificationManagerService = mGetService.invoke(null, Context.NOTIFICATION_SERVICE);
                Class<?> cINotificationManagerStub = Class.forName("android.app.INotificationManager$Stub");
                Method mAsInterface = cINotificationManagerStub.getMethod("asInterface",IBinder.class);
                Object oINotificationManager = mAsInterface.invoke(null,oNotificationManagerService);
                Method mGetZenMode = cINotificationManagerStub.getMethod("getZenMode");
                zenMode = (int) mGetZenMode.invoke(oINotificationManager);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
            return zenMode;
        }
    
        // 关闭手机
        public static void shutDown() {
            try {
                Class<?> cServiceManager = Class.forName("android.os.ServiceManager");
                Method mGetService = cServiceManager.getMethod("getService",String.class);
                Object oPowerManagerService = mGetService.invoke(null,Context.POWER_SERVICE);
                Class<?> cIPowerManagerStub = Class.forName("android.os.IPowerManager$Stub");
                Method mShutdown = cIPowerManagerStub.getMethod("shutdown",boolean.class,String.class,boolean.class);
                Method mAsInterface = cIPowerManagerStub.getMethod("asInterface",IBinder.class);
                Object oIPowerManager = mAsInterface.invoke(null,oPowerManagerService);
                mShutdown.invoke(oIPowerManager,true,null,true);
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    
        public static void shutdownOrReboot(final boolean shutdown, final boolean confirm) {
            try {
                Class<?> ServiceManager = Class.forName("android.os.ServiceManager");
                // 获得ServiceManager的getService方法
                Method getService = ServiceManager.getMethod("getService", java.lang.String.class);
                // 调用getService获取RemoteService
                Object oRemoteService = getService.invoke(null, Context.POWER_SERVICE);
                // 获得IPowerManager.Stub类
                Class<?> cStub = Class.forName("android.os.IPowerManager$Stub");
                // 获得asInterface方法
                Method asInterface = cStub.getMethod("asInterface", android.os.IBinder.class);
                // 调用asInterface方法获取IPowerManager对象
                Object oIPowerManager = asInterface.invoke(null, oRemoteService);
                if (shutdown) {
                    // 获得shutdown()方法
                    Method shutdownMethod = oIPowerManager.getClass().getMethod(
                            "shutdown", boolean.class, String.class, boolean.class);
                    // 调用shutdown()方法
                    shutdownMethod.invoke(oIPowerManager, confirm, null, false);
                } else {
                    // 获得reboot()方法
                    Method rebootMethod = oIPowerManager.getClass().getMethod("reboot",
                            boolean.class, String.class, boolean.class);
                    // 调用reboot()方法
                    rebootMethod.invoke(oIPowerManager, confirm, null, false);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

**调用相应的方法：**

try {
                // 创建对象
                ReflectClass.reflectNewInstance();
    
                // 反射私有的构造方法
                ReflectClass.reflectPrivateConstructor();
    
                // 反射私有属性
                ReflectClass.reflectPrivateField();
    
                // 反射私有方法
                ReflectClass.reflectPrivateMethod();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
            Log.d(TAG," zenmode = " + ReflectClass.getZenMode());

**执行程序：**

08-27 15:11:37.999 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectNewInstance book = Book{name='Android进阶之光', author='刘望舒'}
    08-27 15:11:38.000 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectPrivateConstructor book = Book{name='Android开发艺术探索', author='任玉刚'}
    08-27 15:11:38.000 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectPrivateField tag = BookTag
    08-27 15:11:38.000 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectClass: reflectPrivateMethod string = I am declaredMethod 1 !
    08-27 15:11:38.004 11987-11987/com.android.peter.reflectdemo D/peter.log.ReflectDemo:  zenmode = 0