java的反射机制

定义：

将类的组成部分【成员变量，构造方法，成员方法】通过类加载器【ClassLoad】，封装为其他对象**【成员变量封装成Field[],构造方法封装为Constructor[],成员方法封装为Method[]】

---

java代码在计算机中经历的阶段

源码阶段在硬盘中，通过类加载器加载到内存中，运行阶段可以创建对象等。

---

好处：

1，可以在程序运行过程中操作【执行，设置】这些对象

idea是一个软件程序【打开软件时表示idea程序已经在运行】，在这个软件程序中定义了一个变量str，str.后面会有提示，提示来源是因为idea内部使用了反射机制。
str定义好了之后，会将str字节码文件加载到内存，内存中有个Class对象，Class对象已经将String类所有的方法抽取出来封装到Methods中，然后将String中所有的方法名展示到提示框内。
2，解耦，提高程序的可扩展性

---

获取Class对象的方式：三个方式对应程序运行的三个阶段

1，源代码阶段【硬盘】：
Class.forName(“包名.类名”)：将字节码文件加载到内存，返回Class对象
2，Class类阶段【内存】内存中已经存在类：
类.class:通过类的class属性来获取Class对象。
3，代码运行时阶段 [ 对象已经存在 ]：
对象.getClass：getClass方法在Object对象定义，所有的对象继承其方法。

public static void main(String[] args) throws Exception {
         //Class.forName(“包名.类名”)：
        Class cls1=Class.forName("com.xjbt.domain.Person");
        System.out.println(cls1);
        //类.class:通过类的class属性来获取Class对象。
        Class cls2=Person.class;
        System.out.println(cls2);
        //对象.getClass：getClass方法在Object对象定义，所有的对象继承其方法。
        Person person = new Person();
        Class cls3=person.getClass();
        System.out.println(cls3);
        //打印结果
        /*
            class com.xjbt.domain.Person
            class com.xjbt.domain.Person
            class com.xjbt.domain.Person
        **/

        //检验获取的Class对象是不是同同一个对象(对内存内存地址一样)
        System.out.println(cls1==cls2);
        System.out.println(cls1==cls3);
        //打印结果true  说明是同一个Class对象
    }

---

*Class对象功能:

获取成员变量们：获取到成员变量后设置set(对象，属性值)和获取[get(对象)]成员变量的值
Field[] getFields()：获取所有public修饰的成员变量
Field getField(String name)：获取指定名称且public修饰的成员变量
Field[] getDeclaredFields()：获取所有的成员变量不考虑修饰符
私有变量.setAccessible(true);在设置或获取私有成员变量值前使用暴力反射
Field getDeclaredField(String name)：获取指定名称的的成员变量

 public static void main(String[] args) throws Exception {
        //获取Class对象
        Class classPerson= Person.class;
       
         /**
         * getFlieds
         */
        for (Field field:classPerson.getFields()) {
            System.out.println(field);
        }
        //打印结果:public java.lang.String com.xjbt.domain.Person.a
        //结论：classPerson.getFields()只能获取到public修饰的成员变量
        System.out.println("--------------");

        /**
         * setFiled
         */
        Field a=classPerson.getField("a");
        Person p=new Person();

        //获取对象成员变量的值 get()
        Object valueGet = a.get(p);
        System.out.println(valueGet);
        //结果：null
        //结论：此时p对象a成员变量未赋值

        //设置对象成员变量的值 set()
        a.set(p,"小明");
        System.out.println(p);
        //结果:Person{name='null', age=0, a='小明', b='null', c='null', d='null'}
        //结论：p对象a属性已经赋值
        System.out.println("=================");

        /**
         * Field[] getDeclaredFields()
         */
        for (Field field:classPerson.getDeclaredFields()) {
            System.out.println(field);
        }
        //结果：
        //private java.lang.String com.xjbt.domain.Person.name
        //private int com.xjbt.domain.Person.age
        //public java.lang.String com.xjbt.domain.Person.a
        //protected java.lang.String com.xjbt.domain.Person.b
        //java.lang.String com.xjbt.domain.Person.c
        //private java.lang.String com.xjbt.domain.Person.d
        //结论：打印出所有成员变量
        System.out.println("-----------");

        /**
         * Field getDeclaredField(String name)
         */
        Field d=classPerson.getDeclaredField("d");
        d.setAccessible(true);//暴力反射（想要设置或着获取对象私有变量时，必须用暴力反射）
        Object valueFGetD = d.get(p);
        System.out.println(valueFGetD);
        //结果:设置成功
        d.set(p,"私有变量值也可设置");
        System.out.println(p);
        //结果设置成功：Person{name='null', age=0, a='小明', b='null', c='null', d='私有也可设置'}
    }

2.获取构造方法们:构造器一般没有修饰
Constructor<?>[] getConstructors()
Constructor<T> getConstructor(类<?>... parameterTypes)
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
主要用来创建对象：
构造方法class类.newInstance(实体类构造方法参数.class,...)实体类有几个参数，写几个class
如果是无参构造方法类创建对象：
实体类class.newInstance()直接创建对象

public static void main(String[] args) throws Exception {
        //获取Class对象
        Class classPerson= Person.class;
        //获取有参构造方法对象
        Constructor constructor1=classPerson.getConstructor(String.class,int.class);//传构造方法里的值
        System.out.println(constructor1);
        //创建对象
        Person p= (Person) constructor1.newInstance("张三",20);
        System.out.println(p);
        System.out.println("---------------------------");
        //获取无参构造方法
            //第一种
                Constructor constructor2=classPerson.getConstructor();//传构造方法里的值
                System.out.println(constructor2);
                //创建对象
                Object p2=constructor2.newInstance();
                System.out.println(p2);
            //第二种
                Object p3=classPerson.newInstance();
                System.out.println(p3);

    }

3.获取成员方法们:
Method[] getMethods()
Method getMethod(String name, 类<?>... parameterTypes)
Method[] getDeclaredMethods()
Method getDec laredMethod(String name, 类<?>... parameterTypes)
主要用来执行方法：
成员方法class类.invoke(实体类对象，实体类构造方法参数.class,...)实体类有几个参数，写几个class

 public static void main(String[] args) throws Exception {
        //获取Class对象
        Class classPerson = Person.class;

        Method[] methods=classPerson.getMethods();
        for (Method m:methods) {
            System.out.println(m);//不仅有实体类还有很多Object的方法
            System.out.println(m.getName());//获取方法名称
        }

        Method eat=classPerson.getMethod("eat");//获取无参方法类
        Person p=new Person();
        eat.invoke(p);//执行无参方法
        System.out.println("-----------");
        Method eat2=classPerson.getMethod("eat",String.class);
        eat2.invoke(p,"饭");
    }

4.获取类名
String getName()