JavaSE 反射机制

反射机制是什么

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象，而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

---

反射机制能做什么

反射机制主要提供了以下功能：
1.在运行时判断任意一个对象所属的类；
2.在运行时构造任意一个类的对象；
3.在运行时判断任意一个类所具有的成员变量和方法；
4.在运行时调用任意一个对象的方法；
5.生成动态代理。

---

获取class文件对象的三种方式

每个类被加载之后，系统就会为该类生成一个对应的class对象，通过该class对象就可以访问到JVM中的这个类的字节码文件。
在Java程序中获得class对象通常有如下3种方式。(比如要获取Student类的class对象)
1.使用class类的forName（String clazzName）方法

//必须是全限定名（添加包名）
Class c1 = Class.forName("com.bean.Student");

2.调用某个类的class属性来获取该类对应的Class对象。

//Student.class会返回Student类对应的class对象
Class c2 = Student.class;

3.调用某个对象实例的getClass（)方法

//Object类中的方法，该方法会返回该对象所属类对应的Class对象
Student s = new Student();
Class c3 = s.getClass();

一旦获取了某个类对应的class对象之后，程序就可以调用class对象的方法来获取该对象和该类的真实信息了。

---

通过反射获取类的信息

要获取类的信息，先获取类的类类型，即Class c = obj.Class();

类：Class类的基本操作的
1、class.getName()可以获取类的名称
2、class.getSimpleName();//不包含包名的类的名称
3、class.getMethods()获取类的【public方法】集合，【包括继承来的】

public class reflect {
    public static void main(String args[]){
        Class c1 = int.class; //int的类类型
        Class c2 = String.class; //String类的类类型 String类字节码
        Class c3 = double.class; 
        Class c4 = Double.class; 
        Class c5 = void.class;

        System.out.println(c1.getName());// 输出int
        System.out.println(c2.getName());//输出Java.lang.String 类的全称
        System.out.println(c2.getSimpleName());//输出String 不包含包名的类的名称
    }
}

方法：Method类的基本操作
Method类封装了关于方法的操作
1.method.getName()获取方法名
2.method.getReturnType()获取方法的返回值
3.method.getParameterTypes()，获取方法的参数类型的类类型数组class[]

public class reflect {
    public static void main(String args[]){  
        Class c2 = String.class; 
        Method[] ms = c2.getMethods();
        for(int i =0;i<ms.length;i++){
            //获取到方法的返回值类型
            Class returnType = ms[i].getReturnType();
            System.out.print("返回值类型："+returnType.getName()+" ");
            //得到方法名称
            System.out.print("方法名："+ms[1].getName()+"(");
            //获取到参数类型
            Class[] paramTypes = ms[i].getParameterTypes();
            for(Class class1:paramTypes){
                System.out.print(class1.getSimpleName()+" ");
            }
            System.out.println(")");
        }
    }
}

输出String的方法：

成员变量：Field类的基本操作
Field类封装了关于成员变量的操作
1、Field[] fs = Class.getFields()方法获取所有public的成员变量Field[]信息
2、Class.getDeclaredFields获取的是该类自己声明的成员变量信息，无论private/public
4、field.getType()获得成员类型的类类型
5、field.getName()获得成员的名称

//student类
public class student {
    private String name;
    private String school;
    private boolean has_girlfrend;
    private double age;
    private Object car;
    private Object house;
    private String[] major;
    private String birthday;
}

import java.lang.reflect.Field;

public class reflect {
    public static void main(String args[]){  
        Class c = student.class;
        Field[] fs = c.getDeclaredFields();
        for(Field field:fs){
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName+" "+fieldName);
        }   
    }
}

构造器：Constructor类基本操作
Constructor类封装了关于构造器的操作，通过Class.getConstructor()获得Constructor[]所有公有构造方法信息
1.建议getDeclaredConstructors()获取自己声明的构造方法
2.Constructor.getName():获取构造方法的名字
3.Constructor.getParameterTypes():获取构造方法的参数

//student类
public class student {
    private String name;
    private String school;
    private boolean has_girlfrend;
    private double age;
    private Object car;
    private Object house;
    private String[] major;
    private String birthday;

    public student(String name){
        this.name = name;
    }

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

import java.lang.reflect.Constructor;

public class reflect {
    public static <T> void main(String args[]){  
        Class c = student.class; 
        Constructor[] cs = c.getDeclaredConstructors();
        for(Constructor<T> constructor:cs){
            //获取构造器的名字
            System.out.print(constructor.getName()+"(");
            //获取构造器的参数列表 ---》得到的吃参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for(Class class1:paramTypes){
                System.out.print(class1.getName()+" ");
            }
            System.out.println(")");
        }
    }   
}

输出：

---

通过反射创建对象

通过反射来生成对象的方式有两种:
1.使用Class对象的newInstance()方法来创建该Class对象对应类的实例(这种方式要求该Class对象的对应类有默认构造器).

//通过无参构造器创建对象
Class c1 = Class.forName("com.bean.student");
Student s = (Student)c1.newInstance();

2.先使用Class对象获取指定的Constructor对象, 再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例(通过这种方式可以选择指定的构造器来创建实例).

//通有参构造器创建对象
Class c1 = Class.forName("com.bean.Student");
//获取有参构造
Constructor c = c1.getConstructor(String.class,int.class);
Student p = (Student)c.newInstance("张三"，23)；

---

通过反射获取方法并使用

当获取到某个类对应的Class对象之后, 就可以通过该Class对象的getMethod来获取一个Method数组或Method对象.每个Method对象对应一个方法,在获得Method对象之后,就可以通过调用invoke方法来调用该Method对象对应的方法.

Class c1 = Class.forName("com.bean.Student");
Constructor c = c1.getConstructor(String.class,int.class);
Student s = (Student)c.newInstance("张三"，23);

Method m = c1.getMethod("eat");             //获取eat方法，无参
m.invoke(p);                                    //执行eat方法

Method m2 = c1.getMethod("eat",int.class);  //获取eat方法，有参
m2.invoke(p,10);                                //执行eat有参方法

---

通过反射获取成员变量并使用

通过Class对象的的getField()方法可以获取该类所包含的全部或指定的成员变量Field,Filed提供了如下两组方法来读取和设置成员变量值.

1.getXxx(Object obj): 获取obj对象的该成员变量的值, 此处的Xxx对应8种基本类型,如果该成员变量的类型是引用类型, 则取消get后面的Xxx;
2.setXxx(Object obj, Xxx val): 将obj对象的该成员变量值设置成val值.此处的Xxx对应8种基本类型, 如果该成员类型是引用类型, 则取消set后面的Xxx;

Class c1 = Class.forName("com.bean.Person");
Constructor c = c1.getConstructor(String.class,int.class);
Student s = (Student)c.newInstance("张三"，23); 

Field f = c1.getDeclaredField("name");        //暴力获取字段
f.setAccessible(true);                        //去除私有权限
f.set(p,"李四")；                                //更改名字

---

PS:反射的操作都是编译之后的操作
泛型是防止错误输入的，只在编译阶段有效，编译之后是去泛型化的.

ArrayList list = new ArrayList();
ArrayList<String> list1 = new ArrayList<String>;

Class c1 = list.getClass();
Class c2 = list1.getClass();
System.out.println(c1==c2); //输出true

但是我们可以通过反射来操作，绕过编译。

Method m = c2.getMethod("add",Object.class);
m.invoke(list1, 20);
System.out.println(list1.toString()); //输出[20]

这样就把20加到list1中了。