反射：class类对象的应用

People：

package com.javaWeb01;

public class Person {
    private int age;
    private String name;
    public String a;
    protected String b;
    String c;
    private String d;
    public Person() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat(String name){
        System.out.println(name+"吃苹果");
    }
    public String run(String name){
        System.out.println(name+"跑步");
        return name;
    }
}

reflect:

package com.javaWeb01;

public class reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过Class.forName()获取class对象
       Class c1= Class.forName("com.javaWeb01.Person");
        System.out.println(c1);
        //通过类名.class获取class对象
        Class c2=Person.class;
        System.out.println(c2);
        //通过对象.getClass()方法获取class对象
        Person p=new Person();
        Class c3=p.getClass();
        System.out.println(c3);
        //比较c1、c2、c3是否是指向同一个对象,如果两个都等于就等于三个都是一样
        System.out.println(c1==c2);
        System.out.println(c1==c3);
        Student s=new Student();
        Class s1=s.getClass();
        System.out.println(s1==c1);
    }

}

Test:通过class对象获取成员变量、获取成员方法，获取构造方法的应用：

package com.javaWeb01;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

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

public class TestC {

   /* @Before
    public void init() {
        System.out.println("init...");
    }

    @After
    public void close() {
        System.out.println("close...");
    }*/

    @Test
    public void sum() {
        int r = 1 + 3;
        System.out.println("sum...");
        Assert.assertEquals(4, r);
    }

    @Test
    public void add() {
        CarTest c = new CarTest();
        int result = c.add(1, 4);
        Assert.assertEquals(5, result);
    }

    @Test
    public void shuchu() {
        Person p = new Person();
        System.out.println(p);
    }

    /*
    *获取成员变量
Field[] getFields()          //获取所有public修饰的成员变量
Field getField(String name)  //获取指定名称的public修饰的成员变量
* 获取了成员变量有两种用途：1、设置值；2、获取值

Field[] getDeclaredFields()  //获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)  //获取指定的成员变量，不考虑修饰符
    */
    @Test
    public void FieldTest() throws Exception {
        Class personClass = Person.class;
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("===================");
        Field f = personClass.getField("a");
        Person p = new Person();
        Object a = f.get(p);
        System.out.println(a);
        System.out.println("===================");
        f.set(p, "A");
        Object aa = f.get(p);
        System.out.println(aa);
        System.out.println(p);//输出的是p.toString
        System.out.println("===================");
        Field[] fields2 = personClass.getDeclaredFields();
        for (Field field : fields2) {
            System.out.println(field);
        }
        System.out.println("===================");
        Field dvalue = personClass.getDeclaredField("d");
        dvalue.setAccessible(true);//暴力反射
        Object valued = dvalue.get(p);
        System.out.println(valued);

    }

    /*
    Constructor<?>[] getConstructors() //获取所有public修饰的构造函数
Constructor<T> getConstructor(类<?>... parameterTypes)  //获取指定的public修饰的构造函数

Constructor<?>[] getDeclaredConstructors()  //获取所有的构造函数，不考虑修饰符
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  //获取指定的构造函数，不考虑修饰符
     */

    @Test
    public void constructorTest() throws Exception {
        Class personClass = Person.class;
        Constructor personClassConstructor = personClass.getConstructor(int.class, String.class);//获取构造方法
        Object p = personClassConstructor.newInstance(22, "Lali");//有了构造方法就可以创建对象
        System.out.println(p);
        System.out.println("=========================");
        Constructor personClassConstructor1 = personClass.getConstructor();//获取了无参构造函数
        Object o = personClassConstructor1.newInstance();
        System.out.println(o);
        //如果是想使用空参构造方法，可以用简单的方法，Class类提供了newInstance()空参构造器
        System.out.println("=========================");
        Object o1 = personClass.newInstance();
        System.out.println(o1);

        //personClassConstructor1.setAccessible(true);暴力反射

        System.out.println("=========================");
        Constructor[] personClassConstructors = personClass.getConstructors();
        for (Constructor classConstructor : personClassConstructors) {
            System.out.println(classConstructor);
        }

    }

    /*
    Method[] getMethods()           //获取所有public修饰的成员方法
Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法

Method[] getDeclaredMethods()  //获取所有的成员方法，不考虑修饰符
Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法，不考虑修饰符
     */
    @Test
    public void MethodTest() throws Exception {
        Class personClass = Person.class;
        Person p = new Person();
        Method[] methods = personClass.getMethods();//注意：获取到的方法不仅仅是Person类内自己的方法
        for (Method method : methods) {
            System.out.println(method); //继承Object中的方法也会被获取到（当然前提是public修饰的）
            // method.setAccessible(true);//暴力反射，在反射面前没什么隐私
            String name = method.getName();
            System.out.println(name);
        }
        System.out.println("====================");
        Constructor personClassConstructor = personClass.getConstructor(int.class, String.class);
        Object o = personClassConstructor.newInstance(22, "la");
        System.out.println(o);
        Method toString = personClass.getMethod("toString");
        Object invoke = toString.invoke(p);
        System.out.println(invoke);
        System.out.println("====================");
        Method eat = personClass.getMethod("eat", String.class);
        Object oeat = eat.invoke(p, "lali");//如果方法有返回值类型可以获取到，没有就为null
        System.out.println(oeat);//因为eat方法没有返回值，故输出nul
        System.out.println("====================");
        Method run = personClass.getMethod("run", String.class);
        Object o1 = run.invoke(p, "li");
        System.out.println(o1);
        System.out.println("====================");
        //获取类名
        String name = personClass.getName();
        System.out.println(name);
        //获取public修饰的成员变量
        System.out.println("====================");
        Field field = personClass.getField("a");
        field.set(p, "A++");
        Object o2 = field.get(p);
        System.out.println(o2);
    }
}