Class<?> 方法和构造

代码：

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)
          *   
          */
      
    }