迷人的java反射机制

java的反射机制

定义

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种 动态 获取信息以及动态调用对象方法的功能称为java语言的反射机制。

java经编译后生成xxx.class文件，把一个类划分几块
fileds
constructors
methods

话不多说，先做一个实体类 Person

public class Person {
    private String name;
    private int age;
    public int num;
    public String sex;

    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void sayHello(){
        System.out.println("hello.......");
    }
    public void sayHello(String name){
        System.out.println("hello  "+name);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", num=" + num +
                ", sex='" + sex + '\'' +
                '}';
    }
}

下面我们来进行测试，怎么获取类名，所有的字段名，给字段名设置值，方法名以及方法的参数类型，返回值类型等等。。。。

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        //获取Person得Class对象
        Class<Person> personClass = Person.class;
        //获取所有public的属性变量对象
        Field[] fields = personClass.getFields();
        //获取指定public的属性变量对象
        Field sex = personClass.getField("sex");
        Person p = new Person();
		//赋值
        sex.set(p,"nan");
        System.out.println(p);
		//得到p对象的sex值
        Object o = sex.get(p);
        System.out.println(o.toString());
		//获取所有的公共字段
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("=========getDeclaredFields()=============");
        //getDeclaredFields():获取所有的成员变量，不考滤修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        Field age = personClass.getDeclaredField("age");
        //暴力反射，忽略访问安全权限的修饰符检查，不设置就只能设置public修饰得属性值
        age.setAccessible(true);
        age.set(p,12);
        System.out.println(p);
        System.out.println("+++++++++++++++++++++++");
        Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        Constructor<Person> constructor = personClass.getConstructor(String.class,int.class);
        System.out.println("#################################");
        System.out.println(constructor);
        Person person = constructor.newInstance("ljk",100);
        System.out.println(person);

        //无参数够造方法1
        Constructor<Person> constructor1 = personClass.getConstructor();
        Person person1 = constructor1.newInstance();
        //无参数够造方法2
        Person person2 = personClass.newInstance();

        Method hello = personClass.getMethod("hello");
        //执行指定对象的方法
        hello.invoke(p);

        Method hello1 = personClass.getMethod("hello",String.class);
        // 用 invoke 来执行指定对象的方法
        hello1.invoke(p,"ljk");	
    }
}

这就是反射的魅力！！！