java 基础之--反射详解

java 反射绝大部分都位于 java.lang.reflect package 中；常用的类就是：

1.class类：代表一个类

2.field类：代表类的成员变量

3.method：代表类的方法

4.constructor：代表类的构造方法

5.array：提供动态创建数组，访问数组元素的静态方法

在Java 中无论生成这个类的多少个对象，这个对象都对应同一个class 对象

Class 对象生成的三种方式：

1.使用class类的静态方法。Class.forNanme("packageName"); ---> Class<?> forName =Class.forName("com.project.Test")获取Test类的class 对象;

2.类名.class ；---> Class<?> clazz =Test.class;

3.对象.class()；--->Test te =new Test(); te.getClass(); Class<?> clazz = te.getClass();

使用反射进行方法的调用：

1.获取class对象
2.通过getMethod method obtain specific Method 参数传入（1.方法名，2.方法传入的参数class 类型）
3.获取类的实例
4.调用方法的invoke method  。参数传入（1.类的实例，2.具体方法传入的参数）

This is Example

public class Reflect2 {

    public static void main(String[] args) throws Exception {

        //judge memory
        Class<?> forName = Class.forName("com.java.baseknowledge.reflect.TheReflect");
        System.out.println(forName==TheReflect.class);
        // get  method ,accept method name and class of param
        Method method = forName.getMethod("add", Integer.class,Integer.class);
        //instance  of object
        Object newInstance = forName.newInstance();
        //method invoke,accept instance of object and method param
        System.out.println(method.invoke(newInstance, 4,5));

    }

}

class TheReflect{

    private String name;
    private Integer age;
    public Integer add(Integer param1,Integer param2) {

        return param1+param2;

    }

    public void sayHello(String param1) {

        System.out.println("Hello"+param1);
    }

}

反射通过构造函数的方式进行创建对象的两种方式

1.obtain class object use  generation class object method 

2.通过class对象的.getConstructor（class对象） 方法 obtain specific Constructor

3.通过Constructor 类中的 newInstance(object obj) 方法获取类的实例

而，对于空参数的构造函数对象的创建，我们直接使用
　　　　　　class对象的.newInstance(),就可以创建一个对象，只适用于构造空的构造函数

please fllow me next example

this is Example

public class ReflectConstructor {

    public static void main(String[] args) throws Exception {

        Class<?> name = Class.forName("com.java.baseknowledge.reflect.TheReflect01");

        //obtain constructor
        Constructor<?>[] constructors = name.getConstructors();

        for(int i=0;i<constructors.length;i++) {

            //print all constructors
            System.out.println(constructors[i]);

        }

        //无参构造函数实例创建，direct class object .newInstance
        Object newInstance2 = name.newInstance();
        //有参构造函数执行
        Constructor<?> constructor = name.getConstructor(String.class,Integer.class);

        TheReflect01 newInstance = (TheReflect01)constructor.newInstance("cys",56);

    }

}

class TheReflect01{

    public TheReflect01() {
        System.out.println("no param constructor execute");
    }
    public TheReflect01(String name,Integer age) {
        this.name=name;
        this.age=age;
        System.out.println("有参数构造函数块执行"+name+"...."+age);
    }
    private String name;
    private Integer age;
    public Integer add(Integer param1,Integer param2) {

        return param1+param2;

    }

    public void sayHello(String param1) {

        System.out.println("Hello"+param1);
    }

}

Java 反射如何调用私有的方法与成员变量呢？

1.class 方法中找到带有declared字样的方法基本上都是可以返回所有的成员变量与方法的，不管是private 还是protect ；
2.设置setAccessible（true） 可以压制Java 对特殊修饰符的检查，我们就可以在反射中调用private 方法；

Fllow next Example

package com.java.baseknowledge.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * invocation private method and private property use reflect
 * @author iscys
 *
 */
public class InvocationPrivate {

    public static void main(String[] args) throws Exception {

        Class<?> forName = Class.forName("com.java.baseknowledge.reflect.primitive01");

        //obtain private method
        Method declaredMethod = forName.getDeclaredMethod("TestReflect", new Class[] {String.class,String.class});

        //instance of object
        Object newInstance = forName.newInstance();

        //set accessiable,suppress Java language access check，压制Java 语法检查，就可以进行调用private 方法了

        declaredMethod.setAccessible(true);

        //invoke method

        declaredMethod.invoke(newInstance, "test01","test02");

        System.out.println("....private field ");
        //invoke private property
        Field declaredField = forName.getDeclaredField("name");
        declaredField.setAccessible(true);
        declaredField.set(newInstance, "iscys");
        Object object = declaredField.get(newInstance);
        System.out.println(object);

    }

}

/**
 * defined private method
 * @author iscys
 *
 */
class primitive01{

    private String name;

    private void TestReflect(String param,String param1) {

        System.out.println("this invoke private methood start.."+param+".."+param1);

    }

}