利用java反射访问对象

1：利用java反射，访问构造函数

访问构造函数

import java.lang.reflect.Constructor;
public class App {
    public static void main(String[] args) throws Exception {
        stu stu1=new stu("silves",20);//创建对象
        Class<? extends stu> c=stu1.getClass();//将对对象转化为class
        Constructor<?> cons[]=c.getDeclaredConstructors();//将返回一个构造函数的数组
        for (int i = 0; i < cons.length; i++) {//遍历及输出
            System.out.println(cons[i].isVarArgs());//判断参数个数是否可变
        }
    }
}
class stu{
    public String name;
    public int age;
    public stu(String name,int age){
        this.name=name;
        this.age=age;
    }
    public stu(int ...age){//此参数无任何意义，仅用于观察输出
        this.name="test";
        this.age=19;
    }
    
}

按照我的理解，感觉更好理解这个

1. 先创建一个class对象，再将class对象提取出构造函数
2. 再将此就构造函数存储到集合中
3. 遍历出每一个构造函数后，再进行其他操作
   Constructor常用方法

isVarArgs()//判断构造函数中的参数是否数量可变
getName()//返回类体名称
getParameterTypes()//返回构造函数方法各个参数的类型

注意当使用getParameterTypes()方法时，返回值为class对象，需要遍历之后才能正常输出，代码：

import java.lang.reflect.Constructor;
public class App {
    public static void main(String[] args) throws Exception {
        stu stu1=new stu("silves",20);
        Class<? extends stu> c=stu1.getClass();
        Constructor<?> cons[]=c.getDeclaredConstructors();
        for (Constructor<?> constructor : cons) {
            Class<?> cs[]=constructor.getParameterTypes();
            for (Class<?> constructor2 : cs) {
                System.out.println(constructor2);
            }
        }
    }
}
class stu{
    public String name;
    public int age;
    public stu(String name,int age){
        this.name=name;
        this.age=age;
    }
    public stu(int ...age){
        this.name="test";
        this.age=19;
    }
    
}

访问成员变量

访问成员变量与访问构造函数相似，步骤差不多

1. 创建类体对象，并使用getclass()函数，创建class函数
2. 从class对象中提取出成员变量，并存储到数组中
3. 遍历数组，输出

import java.lang.reflect.Field;
public class App {
    public static void main(String[] args) throws Exception {
        stu stu1=new stu("silves",20);//创建对象
        Class<? extends stu> c=stu1.getClass();//将对象转化为class对象
        Field fs[]=c.getDeclaredFields();//将对象中的成员变量存储到fs[]中
        for (Field field : fs) {
            System.out.println(field.getName());
        }
    }
}
class stu{
    public String name;
    public int age;
    public stu(String name,int age){
        this.name=name;
        this.age=age;
    }
    public stu(int ...age){
        this.name="test";
        this.age=19;
    }
}

关于访问成员变量相关方法

getType()//访问成员变量的值类型
get(obj)//访问成员变量的值，传参为对象
set(obj,value)//设置成员变量的值
setInt(Object obj,int i)//将成员变量中的int型数据变为i
setAccessible()//传参为bool值，如果类体中为private修饰的数据，设置此参数为true，则可以访问到成员变量

访问成员方法

大概思路和上面差不多

import java.lang.reflect.Method;

public class App {
    public static void main(String[] args) throws Exception {
        stu stu1=new stu("silves",20);
        Class<? extends stu> c=stu1.getClass();
        Method ms[]=c.getDeclaredMethods();
        for (Method method : ms) {
            System.out.println(method.getName());
        }
    }
}
class stu{
    public String name;
    public int age;
    private String sex="nan";
    public stu(String name,int age){
        this.name=name;
        this.age=age;
    }
    public stu(int ...age){
        this.name="test";
        this.age=19;
    }
    public void logi(int i){
        System.out.println(i);
    }
    public int lo(){
        System.out.println("无参函数");
        return 1;
    }
    
}

访问函数常用方法

getName()//返回方法名称
getParameterTypes()，返回方法参数的值类型，以class数组的形式
getReturnType()//返回方法返回值类型
isVarArgs()//返回参数是否有可变数量的参数
invoke(obj,args...)//利用指定的参数，调用指定的对象的方法