JavaSE 反射机制

矫情吗；* 2022-06-14 10:14 207阅读 0赞

## **反射机制是什么** ##

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为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的方法：  
![这里写图片描述][SouthEast]

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

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

![这里写图片描述][SouthEast 1]

**构造器：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(")");
            }
        }   
    }

输出：  
![这里写图片描述][SouthEast 2]

--------------------

## **通过反射创建对象** ##

通过反射来生成对象的方式有两种:  
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中了。

[SouthEast]: /images/20220614/d0e2c18a7a574ea9af726088d465ae00.png
[SouthEast 1]: /images/20220614/ec461b897d0742a69cf365b99b63afca.png
[SouthEast 2]: /images/20220614/81be6b5f27564f2eb20a86ad326ef16a.png