反射机制的核心思想

运行时动态访问类与对象的技术

反射在代码层面运用

Class类

class是jvm中代表类和接口的类
class是反射机制的核心,代码层面的关键

Constructor构造方法类

Method方法类

Field成员变量类 getDeclared获取私有属性

相关代码演示

首先创建一个员工对象类Employee

java">package entity;

public class Employee {
    static {
        System.out.println("已经加载到jvm");
    }

    private Integer eno;
    public String ename;
    private Float salary;
    private String dname;


    public Employee() {
        System.out.println("employee 构造方法");
    }

    public Employee(Integer eno, String ename, Float salary, String dname) {
        this.eno = eno;
        this.ename = ename;
        this.salary = salary;
        this.dname = dname;
    }

    public Integer getEno() {
        return eno;
    }

    public void setEno(Integer eno) {
        this.eno = eno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Float getSalary() {
        return salary;
    }

    public void setSalary(Float salary) {
        this.salary = salary;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "eno=" + eno +
                ", ename='" + ename + '\'' +
                ", salary=" + salary +
                ", dname='" + dname + '\'' +
                '}';
    }
     //加薪水方法
    public Employee updateSalary(Float val) {
        this.salary = this.salary + val;
        System.out.println(this.ename + "薪水增加:" + val);
        return this;
    }
}

针对反射相关的四个类进行代码演示

java">import entity.Employee;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Locale;

public class ClassSample {
    public static void main(String[] args) {
        try {
            //核心Class类获取类路径
            Class employeeClass = Class.forName("entity.Employee");
            //构造对象
            Constructor constructor = employeeClass.getConstructor(new Class[]{Integer.class, String.class, Float.class, String.class});
            Employee employee = (Employee) constructor.newInstance(new Object[]{
                    100, "小明", 3000f, "市场营销"
            });//只要是参数都用object传入,只要是类都用class传入
            //获取方法
            Method updateSalaryMethod = employeeClass.getMethod("updateSalary", new Class[]{Float.class});
            //传入对象和参数
            Employee employee1 = (Employee) updateSalaryMethod.invoke(employee, new Object[]{5000f});
            System.out.println(employee1); /*小明薪水更新为:8000.0
            Employee{eno=100, ename='小明', salary=8000.0, dname='市场营销'}*/
            //通过Filed 对属性进行修改
            Field enameFiled = employeeClass.getField("ename");
            enameFiled.set(employee, "小刚");
            String ename = (String) enameFiled.get(employee);
            System.out.println("ename:" + ename);
            //通过getDeclaredFields获取私有属性
            Field[] fields = employeeClass.getDeclaredFields();
            for (Field field : fields) {
                //获取公有属性
                if (field.getModifiers() == 1) {
                    Object val = field.getName();
                    System.out.println(field.getName() + ":" + val);
                } else if (field.getModifiers() == 2) {
                    String methodName = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                    Method getMethod = employeeClass.getMethod(methodName);
                    Object ret = getMethod.invoke(employee);
                    System.out.println(field.getName() + ":" + ret);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

    }
}