反射获取成员方法和成员变量

一、通过反射获取Field对象

Filed中保存的就是类的成员变量。

实现方法：

Field[] getFields()：返回所有公共成员变量的数组
Field[] getDeclaredFidlds（）:返回所有成员变量对象的数组（包括public和private）
Field getField（String name）：返回单个公共成员变量对象，name表示成员变量的名字
Field getDeclaredField（String name）：返回单个成员变量对象（包括public和private）

过程：

1.获取类的字节流对象，获取字节流对象的三种方法：1.类名.class；2.Class.forName(全类名）；3.对象.getClass（）；
2.利用字节码对象，获取Filed对象
3.如果类中的成员变量是被private修饰的则需要setAccessible（true）；暴力反射
4.void set(Object obj,Object value) :给obj对象的成员变量赋值为value
5.Object get（Object obj）返回由该Field表示的字段在之低昂对象上的值
注意：若要获取成员变脸过的value或者给成员变量赋值，那么需要首先使用Constructor创建对象。
6. 给静态成员变量赋值，静态变量不需要对象，格式：set(null,value)
7.field.getName:获取成员变量名字（field是Field的对象）【可以用在field[]数组中，因为数组是获取了类的全部成员变量】

代码实现：

student类：

public class Student {
    
    private String name;
    private int age;
    private String id;
    private String phone;
    private String address;
    private String sexy;

    public Student() {
    
    }

    public Student(String name, int age, String id, String phone, String address, String sexy) {
    
        this.name = name;
        this.age = age;
        this.id = id;
        this.phone = phone;
        this.address = address;
        this.sexy = sexy;
    }

    public String getName() {
    
        return name;
    }

    public void setName(String name) {
    
        this.name = name;
    }

    public int getAge() {
    
        return age;
    }

    public void setAge(int age) {
    
        this.age = age;
    }

    public String getId() {
    
        return id;
    }

    public void setId(String id) {
    
        this.id = id;
    }

    public String getPhone() {
    
        return phone;
    }

    public void setPhone(String phone) {
    
        this.phone = phone;
    }

    public String getAddress() {
    
        return address;
    }

    public void setAddress(String address) {
    
        this.address = address;
    }

    public String getSexy() {
    
        return sexy;
    }

    public void setSexy(String sexy) {
    
        this.sexy = sexy;
    }

    @Override
    public String toString() {
    
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id='" + id + '\'' +
                ", phone='" + phone + '\'' +
                ", address='" + address + '\'' +
                ", sexy='" + sexy + '\'' +
                '}';
    }
}

测试类：

/* * 使用反射的方式向对象中存数据，使用properties文件当做网页传输 * */
public class SaveStudent {
    
    // 使用类加载器读取properties文件
    public static void main(String[] args) throws Exception {
    
        Properties properties = new Properties();
        InputStream in = SaveStudent.class.getClassLoader().getResourceAsStream("Student.properties");
// 存在中文用字符缓冲流包裹一下
        properties.load(new InputStreamReader(in));
// 创建类
        Constructor<Student> constructor = Student.class.getConstructor();
        Student student = constructor.newInstance();
// 使用反射获取类中的成员变量
        Field[] studentField = Student.class.getDeclaredFields();
        for (Field field : studentField) {
    
            field.setAccessible(true);
// 获得成员变量名称
            String name = field.getName();
// 获取key对应的值
            if (name.equals("age")) {
    
                int ageInt = Integer.parseInt(properties.getProperty(name));
                field.set(student, ageInt);
            } else {
    
                // 将值存入存入成员变量
                field.set(student, properties.getProperty(name));
            }
        }
        System.out.println(student);
    }
}

二、通过反射获取Method对象

Method[] getMethods() : 返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods（）:返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name,Class<?>...parameterTypes): 返回单个公共成员方法对象 Method getDeclaredMethod(String name,Class<?>…parameterTypes):
返回单个成员变量方法对象
Class<?>…parameterTypes：表示方法中的形式参数
name：表示方法名称
利用Method对象运行方法
Object invoke（Object obj,Object… args）:运行方法
参数一：用obj对象调用该方法
参数二：调用方法的传递参数（如果没有就不写）
返回值：方法的返回值，没有返回值就不用接收

注意：

如果类的成员方法也被private修饰，则也需要暴力反射：setAccessible（true）

代码实现：

Compute类：

public class Compute {
    
    private int add(int a, int b) {
    
        return a + b;
    }

    private int minus(int a, int b) {
    
        return a - b;
    }

    private int mutiple(int a, int b) {
    
        return a * b;
    }

    private int divid(int a, int b) {
    
        if (b == 0||b<0){
    
            throw new RuntimeException("000000");
        }
        return a / b;
    }
}

测试类：

public class ComputeTest {
    
    public static void main(String[] args) throws Exception {
    
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数：");
        int b = sc.nextInt();
        System.out.println("请输入需要的运算操作：add,minus,mutiply,divid");
        String compute = sc.next();
// 获取字节码对象
        Class<Compute> clazz = Compute.class;
// 创建对象，clazz.newInstance()也可以直接创建对象
        Constructor<Compute> constructor = clazz.getConstructor();
        Compute compute1 = constructor.newInstance();
// 尽量保证所有方法中的参数类型相同
        Method declaredMethods = clazz.getDeclaredMethod(compute,int.class,int.class);
        declaredMethods.setAccessible(true);
        Object res = declaredMethods.invoke(compute1, a, b);
        System.out.println("结果是："+res);
    }
}