反射实现案例

结合以上两篇文章，我们来看看如何在的代码当中实现的。

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 one !";
  break;
     case 1:
  string = "I am declaredMethod two !";
  break;
     default:
  string = "I am declaredMethod three !";
 }

 return string;
    }
}

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

public class ReflectClass {
    private final static String TAG = "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("这本书真不错");
     book.setAuthor("Yang");
     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("这这本书也不错","Yang");
     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/i) {
 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/i, null, false);
     } else {
  // 获得reboot()方法
  Method rebootMethod = oIPowerManager.getClass().getMethod("reboot",
   boolean.class, String.class, boolean.class);
  // 调用reboot()方法
  rebootMethod.invoke(oIPowerManager, /confirm/i, null, false);
     }
 } catch (Exception e) {
     e.printStackTrace();
 }
    }
}

在上面的类当中，我们封装了Java反射的常见的方法，可以作为示例，在我们今后的代码当中使用。

     try {
     // 创建对象
     ReflectClass.reflectNewInstance();

     // 反射私有的构造方法
     ReflectClass.reflectPrivateConstructor();

     // 反射私有属性
     ReflectClass.reflectPrivateField();

     // 反射私有方法
     ReflectClass.reflectPrivateMethod();
 } catch (Exception ex) {
     ex.printStackTrace();
 }

值得注意的是，我们在使用的过程当中，以通过反射获得Method对象为例，一般会提供四种方法，getMethod(parameterTypes)、getMethods()、getDeclaredMethod(parameterTypes)和getDeclaredMethods()。getMethod(parameterTypes)用来获取某个公有的方法的对象，getMethods()获得该类所有公有的方法，但是能不能获得私有方法呢？答案是显而易见的，Method method=clazz.getDeclaredMethod(name);//可以调用类中的所有方法（不包括父类中继承的方法）
　　Method method=clazz.getMethod(name);//可以调用类中有访问权限的方法（包括父类中继承的方法）

在使用反射的过程中，会调用类当中的方法，这里考虑是不是破坏了原有的类的性能。
反射是一个强大的性能，有的人说在反射的过程当中，会破坏安全性以及封装性。确实，反射是一种超常规的一种方式，破坏原有的结构。

所有在使用的过程当中，慎重考虑使用反射功能。