java反射的简单应用

反射：在运行过程中，通过类或者对象使用类中的所有方法或属性。拥有的class文件。
* 获取Class类的对象。
* 方式1：使用类的getClass()方法。
* 方式2：数据类型的.class静态属性。
* 方式3：使用的是Class类的forName()静态方法。类的全路径。
准备：

@SuppressWarnings("all")
class TestPrivateConstructor{
    private TestPrivateConstructor(){
        System.out.println("TestPrivateConstructor私有无参构造。。");
    }
}
@SuppressWarnings("all")
class Test{
    private String name;
    private int age;
    static{
        System.out.println("程序开始执行>>>>>");
    }
    public Test(){
        System.out.println("public默认无参构造执行了。。。。。。。。。。。。");
    }
    public Test(String name){
        System.out.println("public带一个参数构造执行了，参数是："+name);
    }
    public Test(String name,int age){
        System.out.println("public带两个参数构造执行了，第一个参数是："+name+"第二个参数是："+age);
    }
    private Test(int age){
        System.out.println("private私有带一个参数构造执行了，参数值是："+age);
    }
    public void print(){
        System.out.println("public不带参数的方法");
    }
    public void print(String str){
        System.out.println("public带参数的方法执行了，传递值为:"+str);
    }
    public String printHello(String str){
        System.out.println("public带参数的方法执行了，传递值为:"+str);
        return str;
    }
    private void printHello(){
        System.out.println("private私有的方法不带参数方法被调用了");
    }
    private void printHello(String name,int age){
        System.out.println("private私有的方法带参数方法被调用了,name:"+name+"\tage:"+age);
    }
}

开始测试：

@SuppressWarnings("all")
public class ReflectTest {
    public static void main(String[] args) throws Exception{
        //静态代码块执行 获取字节码文件对象
        Class<Test> clazz = (Class<Test>) Class.forName("com.czt.reflect.Test");
        //获得实例,调用无参构造
        Test test = clazz.newInstance();    

        System.out.println("-----------------------------");
        //一个参数的构造
        Constructor<Test> constructor = clazz.getConstructor(String.class);
        Test instance = constructor.newInstance("zhangSan");//必须参数数量，类型

        //两个参数的构造
        Constructor<Test> constructor2 = clazz.getConstructor(String.class,int.class);
        Test instance2 = constructor2.newInstance("Lisi",20);//必须参数数量，类型

        //私有构造
        Constructor<Test> declaredConstructor = clazz.getDeclaredConstructor(int.class);
        declaredConstructor.setAccessible(true);    //设置是否允许访问
        Test newInstance = declaredConstructor.newInstance(20);

        System.out.println("---------------------------------");
        //一个参数的方法
        Method method = clazz.getMethod("print");
        method.invoke(test);

        //私有方法，不带参数
        Method method2 = clazz.getDeclaredMethod("printHello");
        method2.setAccessible(true);
        Object object = method2.invoke(test);
        //待返回值的方法
        Method method4 = clazz.getMethod("printHello", String.class);
        String returnStr = (String) method4.invoke(test, "zhaoSi");
        System.out.println("返回值是："+returnStr);

        //私有方法，带参数
        Method method3 = clazz.getDeclaredMethod("printHello",String.class,int.class);
        method3.setAccessible(true);//***设置访问权限
        Object object2 = method3.invoke(test,"zhangSan",20);


        //私有无参构造
        Class<TestPrivateConstructor> clazz2 = (Class<TestPrivateConstructor>) Class.forName("com.czt.reflect.TestPrivateConstructor");
        Constructor<TestPrivateConstructor> declaredConstructor2 = clazz2.getDeclaredConstructor();
        declaredConstructor2.setAccessible(true);
        TestPrivateConstructor newInstance2 = declaredConstructor2.newInstance();

        //获得所有的非私有构造
        clazz.getConstructors();
        //获得所有的私有构造
        clazz.getDeclaredConstructors();
        //获得所有的非私有方法
        clazz.getMethods();
        //获得所有的私有方法
        clazz.getDeclaredMethods();
    }
}