JAVA--反射机制中方法的使用

测试实体类

public class Person {

    private String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    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;
    }

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

    public void show() {
        System.out.println("我是队长");
    }
    public void show(String name) {
        System.out.println(this.getName() + " 的队长是:" + name);
    }

    private String showNation(String nation) {
        System.out.println(this.getName() + " 的国籍是：" + nation);
        return nation;
    }

}

1: 通过反射获取类的相关信息

    /**
     * 通过反射获取类的相关信息
     */
    @Test
    public void test1() {
        //一般方法创建类对象
        Person person = new Person("Tom", 16);
        System.out.println(person);

        Class clazz = Person.class;
        try {
            //1: 通过反射创建Person类对象
            System.out.println("1: 通过反射创建Person类对象");
            Constructor constructor = clazz.getConstructor(String.class, int.class);
            Object tom = constructor.newInstance("Tom", 12);
            Person p = (Person) tom;
            System.out.println(p);

            //2: 通过反射调用对象指定的属性,方法
            System.out.println("2: 通过反射调用对象指定的属性,方法");
            //通过反射调用属性
            Field age = clazz.getDeclaredField("age");
            age.set(p, 10);
            System.out.println(p);
            //通过反射调用方法
            //无参
            Method show = clazz.getDeclaredMethod("show");
            show.invoke(p);
            //有参
            Method show1 = clazz.getDeclaredMethod("show", String.class);
            show1.invoke(p, "李四");

            //通过反射是可以调用类的私有结构，属性，构造器，方法
            System.out.println("3: 通过反射是可以调用类的私有结构，属性，构造器，方法");
            //调用私有的构造器
            Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class);
            declaredConstructor.setAccessible(true);
            Person p2 = (Person) declaredConstructor.newInstance("王武");
            System.out.println(p2);
            //调用私有属性
            Field name = clazz.getDeclaredField("name");
            name.setAccessible(true);
            name.set(p2, "赵六");
            System.out.println(p2);
            //调用私有的方法
            Method showNation = clazz.getDeclaredMethod("showNation", String.class);
            showNation.setAccessible(true);
            String nation = (String) showNation.invoke(p2, "中国");//相当于调用对象p2的 showNation("中国") 方法
            System.out.println(nation);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行结果：
  Person{name='Tom', age=16}
  1: 通过反射创建Person类对象
  Person{name='Tom', age=12}
  2: 通过反射调用对象指定的属性,方法
  Person{name='Tom', age=10}
  我是队长
  Tom 的队长是:李四
  3: 通过反射是可以调用类的私有结构，属性，构造器，方法
  Person{name='王武', age=0}
  Person{name='赵六', age=0}
  赵六 的国籍是：中国
  中国

2: 获取Class类的实例的方式

    /**
     * Class类的实例对应一个运行时类
     * 获取Class类的实例的方式
     */
    @Test
    public void test2() {
        //方式一: 调用运行时类的属性.class
        Class<Person> clazz1 = Person.class;
        System.out.println("方式一" + clazz1);

        //方式二：通过运行时类的对象调用getClass()
        Person person = new Person();
        Class clazz2 = person.getClass();
        System.out.println("方式二" + clazz2);

        //方式三：调用Class类的静态方法: forName(String classPath)
        try {
            Class clazz3 = Class.forName("com.reflex.Person");
            System.out.println("方式三" + clazz3);

            //三种方法获取的是同一个运行时类
            System.out.println(clazz1 == clazz2);
            System.out.println(clazz1 == clazz3);
            System.out.println(clazz2 == clazz3);

            //方法四：使用类加载器
            ClassLoader classLoader = ReflectionTest.class.getClassLoader();
            Class clazz4 = classLoader.loadClass("com.reflex.Person");
            System.out.println("方式四" + clazz4);
            System.out.println(clazz1 == clazz4);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

运行结果：
方式一class com.reflex.Person
方式二class com.reflex.Person
方式三class com.reflex.Person
true
true
true
方式四class com.reflex.Person
true

3: 使用反射的方式创建对应的运行时类的对象

    /**
     * 使用反射的方式创建对应的运行时类的对象
     */
    @Test
    public void test4() throws Exception {
        Class<Person> clazz = Person.class;
        //newInstance(): 调用此方法创建对应运行时类的对象，
        //此方法内部调用了运行时类空参的构造方法，所以运行时类必须提供空参的构造方法并且方法的访问权限是可以访问到的，通常为public的
        Person person = clazz.newInstance();
        System.out.println(person);
    }
运行结果：
Person{name='null', age=0}