反射简单举例

package test;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionTest {
    //反射之前，对Person的操作
    @Test
    public void test1() {
        //创建Person类的对象
        Person p1 = new Person("Tom", 12);
        //通过对象，调用其内部的属性、方法
        p1.age = 10;

        System.out.println(p1);

        p1.show();
        // 在Person类外部，不可以通过Person类的对象调用其内部私有结构：private
    }

    //反射之后
    @Test
    public void test2() throws Exception {
        Class calzz = Person.class;
        //1.通过反射，创建Person类的对象
        Constructor cons = calzz.getConstructor(String.class, int.class);

        Object obj = cons.newInstance("Tom", 12);

        Person p = (Person) obj;

        System.out.println(p);
        //2.通过反射，调用对象指定的属性、方法
        Field age = calzz.getDeclaredField("age");

        age.set(p, 10);

        System.out.println(p);
        //调用方法
        Method show = calzz.getDeclaredMethod("show");

        show.invoke(p);
        //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性。
        //调用私有的属性
        Constructor cons1 = calzz.getDeclaredConstructor(String.class);

        cons1.setAccessible(true);

        Person p1 = (Person) cons1.newInstance("Jerry");

        System.out.println(p1);
        //调用私有的方法
        Method showNation = calzz.getDeclaredMethod("showNation", String.class);

        showNation.setAccessible(true);

        String nation = (String) showNation.invoke(p1, "中国"); //相当于p1.showNation("中国")

        System.out.println(nation);
    }
}

Person{name='Tom', age=12}
Person{name='Tom', age=10}
hello
Person{name='Jerry', age=0}
中国
中国

进程已结束,退出代码0

package test;

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

    private Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    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 Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public void show() {
        System.out.println("hello");
    }

    private String showNation(String nation) {
        System.out.println(nation);
        return nation;
    }

}

 /*
    关于java.lang.Class类的理解
    1.类的加载过程：
    程序经过javac.exe命令以后，会生成一个或者多个字节码文件(.class结尾)，接着
    我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载
    到内存。此过程就称为类的加载，加载到内存中的类，我们就称为运行时类。就作为Class
    的一个实例。

    2.加载到内存中的运行时类，会缓存一定的时间，在此时间内，我们可以通过不同的方式来获取此运行时类。
     */
    /*
    获取Class的实例的方法
     */
    @Test
    public void test3() throws ClassNotFoundException {
        //方法一:调用运行时类的属性：class
        Class clazz1 = Person.class;

        System.out.println(clazz1);
        //方式二：通过运行时类的对象,调用getClass()
        Person p1 = new Person();

        Class clazz2 = p1.getClass();

        System.out.println(clazz2);
        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("test.Person");

        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);

        System.out.println(clazz1 == clazz3);
        //使用类的加载器
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();

        Class clazz4 = classLoader.loadClass("test.Person");

        System.out.println(clazz4);

        System.out.println(clazz1 == clazz4);
    }
}

class test.Person
class test.Person
class test.Person
true
true
class test.Person
true

进程已结束,退出代码0