Java--反射的基础用法

获取Class对象

public class ReflectTarget {

    public static void main(String[] args) {
        //第1种方式
        ReflectTarget reflectTarget = new ReflectTarget();
        Class  class1 = reflectTarget.getClass();
        System.out.println("第1种："+class1.getName());
        //第2种方式
        Class  class2 = ReflectTarget.class;
        System.out.println("第2种："+class2.getName());
        //第3种方式
        Class  class3 = null;
        try {
            class3 = Class.forName("demo.reflect.ReflectTarget");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("第3种："+class3.getName());
    }
}

第1种：demo.reflect.ReflectTarget
第2种：demo.reflect.ReflectTarget
第3种：demo.reflect.ReflectTarget

获取构造方法并创建实例

/*
 * 通过Class对象可以获取某个类中的：构造方法；
 *
 * 获取构造方法：
 *         1).批量的方法：
 *             public Constructor[] getConstructors()：所有"公有的"构造方法
              public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
 *         2).获取单个的方法，并调用：
 *             public Constructor getConstructor(Class... parameterTypes):获取带参的"公有的"构造方法：
 *             public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
 *
 *             调用构造方法：
 *             Constructor-->newInstance(Object... initargs)
 */
public class ConstructorCollector {
    public static void main(String[] args) throws Exception{
        Class  clazz = Class.forName("demo.reflect.ReflectTarget");
        System.out.println("==============获取所有公有的构造方法==============");
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("==============获取所有的构造方法(包括私有、受保护、默认、公有)==============");
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructors) {
            System.out.println(constructor);
        }
        System.out.println("==============获取带参的公有的构造方法==============");
        Constructor publicConstructor = clazz.getConstructor(String.class, int.class);
        System.out.println(publicConstructor);
        System.out.println("==============获取私有的构造方法==============");
        Constructor privateConstructor = clazz.getDeclaredConstructor(int.class);
        System.out.println(privateConstructor);
        System.out.println("==============调用私有的构造方法==============");
        /*暴力访问(无视访问修饰符)*/
        privateConstructor.setAccessible(true);
        ReflectTarget newInstance = (ReflectTarget) privateConstructor.newInstance(1);
        /*因此私有的单例对象也能通过反射创建出来*/
    }
}

==============获取所有公有的构造方法==============
public demo.reflect.ReflectTarget(char)
public demo.reflect.ReflectTarget()
public demo.reflect.ReflectTarget(java.lang.String,int)
==============获取所有的构造方法(包括私有、受保护、默认、公有)==============
protected demo.reflect.ReflectTarget(boolean)
private demo.reflect.ReflectTarget(int)
public demo.reflect.ReflectTarget(char)
public demo.reflect.ReflectTarget()
demo.reflect.ReflectTarget(java.lang.String)
public demo.reflect.ReflectTarget(java.lang.String,int)
==============获取带参的公有的构造方法==============
public demo.reflect.ReflectTarget(java.lang.String,int)
==============获取私有的构造方法==============
private demo.reflect.ReflectTarget(int)
==============调用私有的构造方法==============
私有有1个参构造函数 i=1

获取成员变量

/*
 * 获取成员变量并调用：
 *
 * 1.批量的
 *      1).Field[] getFields():获取所有的"公有字段,包括父类的字段"
 *      2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有，不包括父类的字段；
 * 2.获取单个的：
 *      1).public Field getField(String fieldName):获取某个"公有的"字段,包括父类的字段；
 *      2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)，不包括父类的字段
 *
 *   设置字段的值：
 *      Field --> public void set(Object obj,Object value):
 *                  参数说明：
 *                  1.obj:要设置的字段所在的对象；
 *                  2.value:要为字段设置的值；
 *
 */
public class FieldCollector {
    public static void main(String[] args) throws Exception{
        Class  clazz = Class.forName("demo.reflect.ReflectTarget");
        System.out.println("==============获取所有公有字段,包括父类的字段==============");
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("==============获取所有的字段(包括私有、受保护、默认、公有，不包括父类的字段)==============");
        Field[] declaredields = clazz.getDeclaredFields();
        for (Field field : declaredields) {
            System.out.println(field);
        }

        System.out.println("==============获取某个公有的字段,包括父类的字段==============");
        Field s = clazz.getField("s");
        System.out.println("公有的字段 s="+s);
        ReflectTarget reflectTarget = (ReflectTarget) clazz.getConstructor().newInstance();
        s.set(reflectTarget,"反射填充的字符串");
        System.out.println("公有的字段赋值后 s="+reflectTarget.s);

        System.out.println("==============获取某个字段(可以是私有的)，不包括父类的字段==============");
        Field i = clazz.getDeclaredField("i");
        System.out.println("私有的字段 i="+i);
        /*暴力访问(无视访问修饰符)*/
        i.setAccessible(true);
        i.set(reflectTarget,1);
        System.out.println(reflectTarget);
    }
}

==============获取所有公有字段,包括父类的字段==============
public java.lang.String demo.reflect.ReflectTarget.s
public java.lang.String demo.reflect.ReflectFartherTarget.fS
==============获取所有的字段(包括私有、受保护、默认、公有，不包括父类的字段)==============
public java.lang.String demo.reflect.ReflectTarget.s
protected boolean demo.reflect.ReflectTarget.b
char demo.reflect.ReflectTarget.c
private int demo.reflect.ReflectTarget.i
==============获取某个公有的字段,包括父类的字段==============
公有的字段 s=public java.lang.String demo.reflect.ReflectTarget.s
公有无参构造函数
公有的字段赋值后 s=反射填充的字符串
==============获取某个字段(可以是私有的)，不包括父类的字段==============
私有的字段 i=private int demo.reflect.ReflectTarget.i
ReflectTarget{s='反射填充的字符串', b=false, c= , i=1}

获取成员方法

/*
 * 获取成员方法并调用：
 *
 * 1.批量的：
 *      public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
 *      public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
 * 2.获取单个的：
 *      public Method getMethod(String name,Class<?>... parameterTypes):
 *                  参数：
 *                      name : 方法名；
 *                      Class ... : 形参的Class类型对象
 *      public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
 *
 *   调用方法：
 *      Method --> public Object invoke(Object obj,Object... args):
 *                  参数说明：
 *                  obj : 要调用方法的对象；
 *                  args:调用方式时所传递的实参；
):
 */
public class MethodCollector {
    public static void main(String[] args)throws Exception {
        Class  reflectTargetClass = Class.forName("demo.reflect.ReflectTarget");
        System.out.println("==============获取所有公有方法；（包含了父类的方法也包含Object类）==============");

        Method[] publicMethods = reflectTargetClass.getMethods();
        for (Method publicMethod : publicMethods) {
            System.out.println(publicMethod);
        }
        System.out.println("==============获取所有的成员方法，包括私有的(不包括继承的)==============");

        Method[] allMethods = reflectTargetClass.getDeclaredMethods();
        for (Method publicMethod : allMethods) {
            System.out.println(publicMethod);
        }
        System.out.println("==============获取有参公有方法并执行==============");
        Method publicMethod = reflectTargetClass.getMethod("callPublic", String.class);
        ReflectTarget reflectTarget = (ReflectTarget) reflectTargetClass.getConstructor().newInstance();
        publicMethod.invoke(reflectTarget,"我是公用方法参数");

        System.out.println("==============获取有参私有方法并执行，带返回值==============");
        Method privateMethod = reflectTargetClass.getDeclaredMethod("callPrivate", int.class);
        privateMethod.setAccessible(true);
        String result = (String) privateMethod.invoke(reflectTarget, 1);
        System.out.println("执行私有方法callPrivate()返回值是 : "+result);
    }
}

==============获取所有公有方法；（包含了父类的方法也包含Object类）==============
public static void demo.reflect.ReflectTarget.main(java.lang.String[])
public java.lang.String demo.reflect.ReflectTarget.toString()
public void demo.reflect.ReflectTarget.callPublic(java.lang.String)
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
==============获取所有的成员方法，包括私有的(不包括继承的)==============
public static void demo.reflect.ReflectTarget.main(java.lang.String[])
public java.lang.String demo.reflect.ReflectTarget.toString()
protected void demo.reflect.ReflectTarget.callProtected(java.lang.String)
void demo.reflect.ReflectTarget.callDefault()
private java.lang.String demo.reflect.ReflectTarget.callPrivate(int)
public void demo.reflect.ReflectTarget.callPublic(java.lang.String)
==============获取有参公有方法并执行==============
公有无参构造函数
调用public方法callPublic,参数 s=我是公用方法参数
==============获取有参私有方法并执行，带返回值==============
调用private方法callPrivate()并有返回值,参数 i=1
执行私有方法callPrivate()返回值是 : 我是返回值1