public class TestClass {
?
    public static void main(String[] args) throws Exception{
        Class<?> clazz = Class.forName("edu.nf.reflect.Users");
        //通过Class对象来创建实例,当前类必须提供一个公开并且无参的构造方法
        Users user = (Users) clazz.newInstance();
        //获取类的完整类名
        System.out.println(clazz.getName());
        //获取类的简单类名
        System.out.println(clazz.getSimpleName());
        //获取类所在的包名
        System.out.println(clazz.getPackage().getName());
        //获取当前类的父类的Class
        System.out.println(clazz.getSuperclass());
        //获取当前类实现的所有接口
        System.out.println(clazz.getInterfaces());
        //获取加载这个类的类加载器
        System.out.println(clazz.getClassLoader());
        //获取公共并且参数类型为String的构造方法
        clazz.getConstructor(String.class);
        //获取私有并且参数为int类型的构造方法
        clazz.getDeclaredConstructor(Integer.TYPE);
        //获取所有公共的构造方法
        Constructor[] consArray1 = clazz.getConstructors();
        //获取所有构造方法，包括公共和是有的
        Constructor[] consArray2 = clazz.getDeclaredConstructors();
        //获取某一个公共的字段,参数指定字段的名字
        Field f1 = clazz.getField("address");
        System.out.println(f1.getName());
        //获取某一个受保护的字段
        Field f2 = clazz.getDeclaredField("tel");
        System.out.println(f2.getName());
        System.out.println("-----------------------");
        //获取所有公共的字段,包括继承自父类的公共字段
        Field[] fieldArray1 = clazz.getFields();
        for (Field field : fieldArray1) {
            System.out.println(field.getName());
        }
        System.out.println("-----------------------");
        //获取所有字段，包括受保护的(不包括继承父类的字段)
        Field[] fieldArray2 = clazz.getDeclaredFields();
        for (Field field : fieldArray2) {
            System.out.println(field.getName());
        }
        System.out.println("-----------------------");
        //获取某一个公共的方法(第一个参数指定方法名，第二个参数指定方法参数的类型,这是一个可变参数，有多少个参数就要指定多少个类型)
        Method m1 = clazz.getMethod("say", String.class);
        System.out.println(m1.getName());
        //获取某一个受保护的方法
        Method m2 = clazz.getDeclaredMethod("call");
        System.out.println(m2.getName());
        System.out.println("-----------------------");
        //获取所有公共的方法(包括继承自父类的公共方法)
        Method[] methodArray1 = clazz.getMethods();
        for (Method method : methodArray1) {
            System.out.println(method.getName());
        }
        System.out.println("-----------------------");
        //获取本类的所有方法，包括受保护的（不包括父类的方法）
        Method[] methodArray2 = clazz.getDeclaredMethods();
        for (Method method : methodArray2) {
            System.out.println(method.getName());
        }
    }
}
?

public class TestCons {
    public static void main(String[] args) throws Exception{
        //加载Users的class信息,并构建Class对象
        Class<?> clazz = Class.forName("edu.nf.reflect.Users");
        //通过class对象访问构造方法信息,
        // 根据构造方法的参数类型获取某一个公共的构造方法
        Constructor cons1 = clazz.getConstructor(int.class);
        // 访问受保护的构造方法
        Constructor cons2 = clazz.getDeclaredConstructor(int.class);
        //构造方法的名称
        System.out.println(cons1.getName());
        //获取构造方法的参数个数
        System.out.println(cons1.getParameterCount());
        //获取定义这个构造方法的Class类
        System.out.println(cons1.getDeclaringClass());
        //通过构造方法来创建类的实例
        //由于构这个造方法是私有的，因此必须强制打开访问开关
        cons1.setAccessible(true);
        //然后通过newInstance方法来创建类的实例,并传入构造方法所需的参数
        Users user = (Users)cons1.newInstance(21);
        //获取所有的构造方法(包括私有和公有的)
        Constructor[] cons = clazz.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println("参数个数: "+con.getParameterCount());
        }
    }
}

public class TestField {
?
    public static void main(String[] args) throws Exception{
        Class<?> clazz = Class.forName("edu.nf.reflect.Users");
        //创建类的实例
        Object instance = clazz.newInstance();
        //获取一个受保护的字段
        Field f = clazz.getDeclaredField("tel");
        //打开访问开关
        f.setAccessible(true);
        //给字段赋值(第一个参数指定当前类的实例，第二个参数是具体的值)
        f.set(instance, "123456");
        //取值(get方法的参数也是指定当前类的实例)
        System.out.println(f.get(instance));
        //获取字段的类型
        System.out.println(f.getType());
        //获取字段的名称
        System.out.println(f.getName());
    }
}

public class TestMethod {
?
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("edu.nf.reflect.Users");
        //构建当前类的实例
        Object instance = clazz.newInstance();
        //获取受保护的call方法
        Method method = clazz.getDeclaredMethod("call", String.class);
        //获取方法的名称
        System.out.println(method.getName());
        //获取方法的返回值类型
        System.out.println(method.getReturnType());
        //获取方法参数的个数
        System.out.println(method.getParameterCount());
        //获取方法的所有参数对象
        System.out.println(method.getParameters());
        //获取方法中所有参数的类型
        Class<?>[] paramsType = method.getParameterTypes();
        for (Class<?> aClass : paramsType) {
            System.out.println(aClass);
        }
        //调用当前方法(第一个参数是当前类的实例，第二个参数开始是方法所需的参数)
        //invoke方法返回的是当前调用的方法的返回值
        //这个方法是受保护的，因此需要先打开访问开关
        method.setAccessible(true);
        Object returnValue = method.invoke(instance, "12345678");
        System.out.println(returnValue);
    }
}
?

public class TestParameter {
?
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("edu.nf.reflect.Users");
        //先获取指定的受保护的方法
        Method callMethod = clazz.getDeclaredMethod("call", String.class);
        //获取该方法的参数信息
        Parameter[] params = callMethod.getParameters();
        for (Parameter param : params) {
            //获取参数的类型
            System.out.println(param.getType());
            //获取参数的名称（在JDK8之前是没有办法获取参数名的，必须通过第三方字节码工具来获取）
            //JDK8默认编译的时候是不会讲参数名信息保存在字节码中
            //如果想要获取参数名，那么在编译时就需要加上编译参数
            //如：javac -parameters Users.java
            System.out.println(param.getName());
        }
    }
}