Class<?> 方法和构造-优快云博客

本文通过一个具体的Java类实例，详细介绍了如何使用Java反射机制来创建对象、调用方法及访问私有成员。文章展示了如何利用反射获取不同类型的构造器、方法和字段，包括那些被标记为私有的。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码：

public class App {
   private String id;
   private String username;
   private App() {
   }
   private App(String id, String username) {
       this.id = id;
       this.username = username;
   }
   public String getHi() {
       return "Hi";
   }
   @SuppressWarnings("unused")
   private String getAppHi(String app) {
       return "AppHi";
   }
   public String getId() {
       return id;
   }
   public void setId(String id) {
       this.id = id;
   }
   public String getUsername() {
       return username;
   }
   public void setUsername(String username) {
       this.username = username;
   }
}

测试类：

public static void main(String[] args) throws Exception {
       Class<?> clazz = App.class;
   /* Class newInstance 方法获取对象，
   * 调用的只能是无参构造器，并且构造方法必须是public类型
   */
       App app1 = (App) clazz.newInstance();
       System.out.println("app1"+app1);

   /* Class getDeclaredConstructors() 获取的是所有的构造器（包括private等所有的），
   * Class getConstructors() 获取的是所以构造器（public类型）
   * 调用的只能是无参构造器，并且构造方法必须是public类型
   */
       Constructor[] cons = clazz.getConstructors();
      for(Constructor C:cons){
       System.out.println(" C :"+C);
      }

   /* Class getDeclaredConstructors() 获取的是所有的构造器（包括private等所有的），
   * Constructor setAccessible(true) 可以关闭权限安全检查，
   * 跳过private 权限，来创建对象，
   */

   Constructor<?>[] cons2 = clazz.getDeclaredConstructors();
   cons2[1].setAccessible(true);
   App app0 = (App) cons2[1].newInstance();
     System.out.println("app0: " + cons2[1]);

   /* Class getDeclaredConstructor(Class[]{...}) 获取的是所有的构造器（包括private等所有的），
   * Constructor setAccessible(true) 可以关闭权限安全检查，
   * 跳过private 安全检查，来创建对象，
   */

     Constructor<?> con4 = clazz.getDeclaredConstructor(new Class[] {String.class,String.class});
     con4.setAccessible(true);
   App app4 = (App)con4.newInstance(new Object[]{"23456","Zxx"});
   System.out.println("app4 :" + app4 );
   System.out.println("Superclass():" + clazz.getSuperclass() );
   System.out.println(" SimpleName :" + clazz.getSimpleName() );


   /*
      * Method获取的是所有的构造器（包括private等所有的），
      * 反射获取指定的方法
      * clazz.getMethod(name, parameterTypes) name :方法的名字，parameterTypes 参数的类型
      */
      Constructor<?>[] cons5 = clazz.getDeclaredConstructors();
      cons5[0].setAccessible(true);
      App app5 = (App) cons[0].newInstance();
      //System.out.println("app5: " + cons5[0]);
      Method method = clazz.getDeclaredMethod("getAppHi", String.class);
      method.setAccessible(true);
      String result = (String) method.invoke(app0, "app");
      System.out.println(" result : " + result);

         /*
          * 总结： Class<?> 的方法和构造器和属性,带Declared 就是包含private
          * 获取所有的方法和构造器和属性(包括private的 )
          * getDeclaredConstructors()
          * getDeclaredMethods()
          * getDeclaredFields()
          *
          * 获取声明中指定的方法和构造器和属性(包含private)
          * getDeclaredConstructors(parameterTypes)
          * getDeclaredMethods(name, parameterTypes)
          * getDeclaredFields(name)
          *
          * 获取所有的方法和构造器和属性(只含有public的 )
          * getConstructors()
          * getMethods()
          * getFields()
          *
          * 获取声明中指定的方法和构造器和属性(只含有public的)
          * getConstructors(parameterTypes)
          * getMethods(name, parameterTypes)
          * getFields(name)
          *
          */

   }