//构造器缓存
private volatile transient Constructor<T> cachedConstructor;
//实例缓存
private volatile transient Class<?>       newInstanceCallerCache;

private transient String name;

private final ClassLoader classLoader;

private Class(ClassLoader loader) {
    // Initialize final field for classLoader.  The initialization value of non-null
    // prevents future JIT optimizations from assuming this final field is null.
    classLoader = loader;
}

public T newInstance()
    throws InstantiationException, IllegalAccessException
{   // 进行安全检查
    if (System.getSecurityManager() != null) {
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
    }

  

  // 每次先检查是否有已经缓存过的构造器，如果没有，则重新获取
    if (cachedConstructor == null) {
        if (this == Class.class) {
            throw new IllegalAccessException(
                "Can not call newInstance() on the Class for java.lang.Class"
            );
        }
        try {
            Class<?>[] empty = {};
            // 获取该类已经声明的的无参构造方法
            final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
           // 此处是为了使无参构造方法可以被访问，因为有时，构造方法被声明为private的
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction<Void>() {
                    public Void run() {
                            c.setAccessible(true);
                            return null;
                        }
                    });
             // 将获取的无参构造方法缓存        
            cachedConstructor = c;
        } catch (NoSuchMethodException e) {
            throw (InstantiationException)
                new InstantiationException(getName()).initCause(e);
        }
    }
    Constructor<T> tmpConstructor = cachedConstructor;
   // 获取构造方法的语言修饰符，诸如public,private,static,final等
    int modifiers = tmpConstructor.getModifiers();
     // 根据已经获取的语言修饰符判断是否具有访问权限，如果没有，则执行以下操作
    if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
        Class<?> caller = Reflection.getCallerClass();
        if (newInstanceCallerCache != caller) {
            Reflection.ensureMemberAccess(caller, this, null, modifiers);
            newInstanceCallerCache = caller;
        }
    }
    // 整个方法的核心，使用类的构造方法来生成实例
    try {
        return tmpConstructor.newInstance((Object[])null);
    } catch (InvocationTargetException e) {
        Unsafe.getUnsafe().throwException(e.getTargetException());
        // Not reached
        return null;
    }
}

public class ReflectDemo {

    private String reflectString = "abc";
    //因为有 *有参构造器* 所有需要显示的定义一个无参构造器用于反射生成实例
    ReflectDemo() {
    }

    ReflectDemo(String reflectString) {
        this.reflectString = reflectString;
    }
    //1.私有方法
    private void priMethod(int a) {
        System.out.println("this is [private] method");
    }
    //2.公有方法
    public void pubMethod() {
        System.out.println("this is [public] method");
    }
    //3.有参方法
    public String getMath(int a, int b) {
        BigDecimal bigDecimalA = BigDecimal.valueOf(a);
        BigDecimal bigDecimalB = BigDecimal.valueOf(b);
        BigDecimal bigDecimal = bigDecimalA.divide(bigDecimalB, 2, RoundingMode.HALF_UP);
        return String.valueOf(bigDecimal);
    }
    //4.可变参数方法
    public String addString(String... args) {
        StringBuilder sb = new StringBuilder();
        for (String arg : args) {
            sb.append(arg).append("|");
        }
        return sb.substring(0, sb.length() - 1);
    }

}

public class App {
    public static void main(String[] args) throws Exception {
        Class<?> reflectDemo = Class.forName("com.project.ReflectDemo");
        Object o1 = reflectDemo.newInstance();
        //获取所有方法
        Method[] methods = reflectDemo.getMethods();

        //1
        Method priMethod = reflectDemo.getDeclaredMethod("priMethod");
        //功能是启用或禁用安全检查
        priMethod.setAccessible(true);
        priMethod.invoke(o1);

        //2
        Method pubMethod = reflectDemo.getMethod("pubMethod");
        pubMethod.invoke(o1);

        //3
        //因为入参是int 基本数据类型，这里也写int.class
        Method pubMethod3 = reflectDemo.getMethod("getMath", int.class, int.class);
        String invoke = (String) pubMethod3.invoke(o1, 10, 3);
        System.out.println(invoke);

        //4
        //可变参数写法，可变参数本质是一个数组，外层需要包一个new Class[]{}, invoke时候包一个new Object[]{}
        //否则报错
        Method pubMethod4 = reflectDemo.getMethod("addString", new Class[]{String[].class});
        Object invoke1 = pubMethod4.invoke(o1,new Object[]{new String[]{"123", "345"}});
        System.out.println(invoke1.toString());

    }
}

/**
 * 将类转换为它的子类Class
 * @param clazz 父类的Class
 * @param <U> 父类
 * @return U的子类Class
 */
public <U> Class<? extends U> asSubclass(Class<U> clazz) {
    // 判断clazz是否是当前类，或者是当前类的父类
    if (clazz.isAssignableFrom(this))
        return (Class<? extends U>) this;
    else
        throw new ClassCastException(this.toString());
}

/**
 * 将给定的类转换为当前Class所代表的类
 * @param obj 需要转换的类
 * @return 当前Class所代表的类
 */
public T cast(Object obj) {
    // obj不为null，并且可以被转换为当前Class代表的类
    // isInstance为native方法，类似于instanceOf的作用
    if (obj != null && !isInstance(obj))
        throw new ClassCastException();
    return (T) obj;
}