자바 고급 특성의 반사

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());