Java面试知识点（六十三）Java反射

╰半橙微兮° 2021-10-01 06:10 355阅读 0赞

> JAVA 反射机制是在**运行状态**中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的**任意一个方法和属性**；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。  
> 实际上，我们**创建的每一个类也都是对象**，即类本身是 java.lang.Class 类的实例对象。这个实例对象称之为类对象，也就是 Class 对象。

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

### 一、概述 ###

反射就是把 java 类中的各种成分映射成一个个的 Java 对象  
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。  
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）  
如图是类的正常加载过程：反射的原理在与 class 对象。  
熟悉一下加载的时候：Class 对象的由来是将 class 文件读入内存，并为之创建一个 Class 对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

*  Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是 jvm 中有 N 多的实例每个类都有该 Class 对象。（包括基本数据类型）
 *  Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM 已经帮我们创建好了。

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

### 二、获取class对象的三种方式 ###

1.  通过object类的 getClass() 函数，由于object是根类，每一个类都有这个函数
2.  每一个类（包括基本数据类型，注意这里基本数据类型不用转成包装类）都有一个class属性，静态属性，通过类名直接访问
3.  通过Class类的静态方法 forName(String className)

package test.reflect;
    
    /** * @author 谢世杰 */
    public class GetClass { 
        public static void main(String[] args) { 
            Student student = new Student();
    
            // 第一种方式
            Class stuClass1 = student.getClass();
            System.out.println(stuClass1.getName());
    
            // 第二种方式
            Class stuClass2 = Student.class;
            System.out.println(int.class.getName());
            System.out.println(stuClass1 == stuClass2);
    
            // 第三种方式
            try { 
                Class stuClass3 = Class.forName("test.reflect.Student");
                System.out.println(stuClass1 == stuClass3);
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
            
        }
    }

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

运行结果：  
test.reflect.Student  
int  
true  
true

**可以看到所有获得到的class对象都是同一个。**

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

### 三、通过反射获取构造函数并使用 ###

*  student类

package test.reflect;
    
    /** * @author 谢世杰 */
    public class Student { 
    	public String id;
        private String name;
        private String sex;
        private int age;
    
        public Student() { 
            System.out.println("公有，无参构造函数");
        }
    
        public Student(String name) { 
            System.out.println("name:" + name);
        }
    
        private Student(int age) { 
            System.out.println("私有构造函数" + age);
        }
    
    	public void test(String name, int age) { 
            System.out.println("name:"+name+" age:"+age);
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public void setSex(String sex) { 
            this.sex = sex;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public int getAge() { 
            return age;
        }
    }

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

*  测试类

package test.reflect;
    
    import java.lang.reflect.Constructor;
    
    /** * @author 谢世杰 */
    public class Constructors { 
        public static void main(String[] args) throws Exception { 
            Class stuClass = Class.forName("test.reflect.Student");
    
            System.out.println("===获得所有公有构造方法===");
            Constructor[] cons = stuClass.getConstructors();
            for (Constructor con : cons) { 
                System.out.println(con);
            }
    
            System.out.println("===获得所有构造方法===");
            Constructor[] cons2 = stuClass.getDeclaredConstructors();
            for (Constructor con : cons2) { 
                System.out.println(con);
            }
    
            System.out.println("===根据参数类型获得指定构造函数===");
            Constructor conNull = stuClass.getDeclaredConstructor(null);
            System.out.println("无参构造函数" + conNull);
            Constructor conInt = stuClass.getDeclaredConstructor(int.class);
            System.out.println("参数为int的构造函数" + conInt);
            Constructor conString = stuClass.getDeclaredConstructor(String.class);
            System.out.println("参数为String构造函数" + conString);
    
            System.out.println("===调用构造函数===");
            Object obj = conNull.newInstance();
            // 注意，私有构造函数需要设置使用权限，否则报错
            conInt.setAccessible(true);
            Object obj2 = conInt.newInstance(10);
        }
    }

运行结果：

===获得所有公有构造方法===
    public test.reflect.Student(java.lang.String)
    public test.reflect.Student()
    ===获得所有构造方法===
    private test.reflect.Student(int)
    public test.reflect.Student(java.lang.String)
    public test.reflect.Student()
    ===根据参数类型获得指定构造函数===
    无参构造函数public test.reflect.Student()
    参数为int的构造函数private test.reflect.Student(int)
    参数为String构造函数public test.reflect.Student(java.lang.String)
    ===调用构造函数===
    公有，无参构造函数
    私有构造函数10

*  getConstructor 根据参数获得公有构造函数
 *  getDeclaredConstructor 根据参数获得任意构造函数
 *  newInstance 执行构造函数，私有构造函数需要开放权限

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

### 四、通过反射获得成员变量并使用 ###

package test.reflect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    
    /** * @author 谢世杰 */
    public class Fields { 
        public static void main(String[] args) throws Exception { 
            Class stuClass = Class.forName("test.reflect.Student");
    
            System.out.println("===所有公有字段===");
            Field[] fields1 = stuClass.getFields();
            for (Field field : fields1) { 
                System.out.println(field);
            }
    
            System.out.println("===所有字段===");
            Field[] fields2 = stuClass.getDeclaredFields();
            for (Field field : fields2) { 
                System.out.println(field);
            }
    
            System.out.println("===根据字段名获取字段并使用===");
            // 获得id字段
            Field field = stuClass.getField("id");
            // 私有字段需要开放权限,公有不需要处理
            field.setAccessible(true);
            // 获取构造函数
            Constructor constructor = stuClass.getConstructor();
            Object obj = constructor.newInstance();
            // 设置字段值
            field.set(obj,"xsj");
            // 查看结果
            Student stu = (Student)obj;
            System.out.println(stu.id);
    
        }
    }

运行结果：

===所有公有字段===
    public java.lang.String test.reflect.Student.id
    ===所有字段===
    public java.lang.String test.reflect.Student.id
    private java.lang.String test.reflect.Student.name
    private java.lang.String test.reflect.Student.sex
    private int test.reflect.Student.age
    ===根据字段名获取字段并使用===
    公有，无参构造函数
    xsj

设置字段的值：  
Field --> public void set(Object obj,Object value):  
参数说明：  
1.obj:要设置的字段所在的对象；  
2.value:要为字段设置的值；

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

### 五、通过反射获取成员函数并使用 ###

package test.reflect;
    
    import java.lang.reflect.Method;
    
    /** * @author 谢世杰 */
    public class Methods { 
        public static void main(String[] args) throws Exception{ 
            Class stuClass = Class.forName("test.reflect.Student");
    
            // 这里获取的方法包括父类的方法
            System.out.println("===获取所有公有方法(包括继承的父类的方法)===");
            Method[] methods1 = stuClass.getMethods();
            for (Method method : methods1) { 
                System.out.println(method);
            }
    
            System.out.println("===获取本类所有方法===");
            Method[] methods2 = stuClass.getDeclaredMethods();
            for (Method method : methods2) { 
                System.out.println(method);
            }
    
            System.out.println("===获取指定方法并使用===");
            Method method = stuClass.getMethod("test",String.class,int.class);
            Object obj = stuClass.getConstructor().newInstance();
            // 调用函数
            method.invoke(obj,"xsj",123);
        }
    }

运行结果：

===获取所有公有方法(包括继承的父类的方法)===
    public java.lang.String test.reflect.Student.getName()
    public void test.reflect.Student.setName(java.lang.String)
    public void test.reflect.Student.test(java.lang.String,int)
    public void test.reflect.Student.setAge(int)
    public void test.reflect.Student.setSex(java.lang.String)
    public java.lang.String test.reflect.Student.getSex()
    public int test.reflect.Student.getAge()
    public final void java.lang.Object.wait() throws java.lang.InterruptedException
    public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
    public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
    public boolean java.lang.Object.equals(java.lang.Object)
    public java.lang.String java.lang.Object.toString()
    public native int java.lang.Object.hashCode()
    public final native java.lang.Class java.lang.Object.getClass()
    public final native void java.lang.Object.notify()
    public final native void java.lang.Object.notifyAll()
    ===获取本类所有方法===
    public java.lang.String test.reflect.Student.getName()
    public void test.reflect.Student.setName(java.lang.String)
    public void test.reflect.Student.test(java.lang.String,int)
    public void test.reflect.Student.setAge(int)
    public void test.reflect.Student.setSex(java.lang.String)
    public java.lang.String test.reflect.Student.getSex()
    public int test.reflect.Student.getAge()
    ===获取指定方法并使用===
    公有，无参构造函数
    name:xsj age:123

调用方法：  
Method --> public Object invoke(Object obj,Object… args):  
参数说明：  
obj : 要调用方法的对象；  
args:调用方式时所传递的实参

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

### 六、通过反射运行配置文件 ###

student：

public class Student { 
    	public void show(){ 
    		System.out.println("is show()");
    	}
    }

配置文件（以TXT为例） ：

className = cn.fanshe.Student
    methodName = show

测试类

import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.lang.reflect.Method;
    import java.util.Properties;
     
    /* * 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改 * 我们只需要将新类发送给客户端，并修改配置文件即可 */
    public class Demo { 
    	public static void main(String[] args) throws Exception { 
    		//通过反射获取Class对象
    		Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
    		//2获取show()方法
    		Method m = stuClass.getMethod(getValue("methodName"));//show
    		//3.调用show()方法
    		m.invoke(stuClass.getConstructor().newInstance());
    		
    	}
    	
    	//此方法接收一个key，在配置文件中获取相应的value
    	public static String getValue(String key) throws IOException{ 
    		Properties pro = new Properties();//获取配置文件的对象
    		FileReader in = new FileReader("pro.txt");//获取输入流
    		pro.load(in);//将流加载到配置文件对象中
    		in.close();
    		return pro.getProperty(key);//返回根据key获取的value值
    	}
    }

控制台输出：  
is show()

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

**需求：**  
当我们升级这个系统时，不要 Student 类，而需要新写一个 Student2 的类时，这时只需要更改 pro.txt 的文件内容就可以了。代码就一点不用改动

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

student2 类：

public class Student2 { 
       public void show2(){ 
       	System.out.println("is show2()");
       }
    }

配置文件更改为：

className = cn.fanshe.Student2
    methodName = show2

控制台输出：  
is show2();

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

### 七、通过反射越过泛型检查 ###

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的

import java.lang.reflect.Method;
    import java.util.ArrayList;
     
    /* * 通过反射越过泛型检查 * * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？ */
    public class Demo { 
    	public static void main(String[] args) throws Exception{ 
    		ArrayList<String> strList = new ArrayList<>();
    		strList.add("aaa");
    		strList.add("bbb");
    		
    	// strList.add(100);
    		//获取ArrayList的Class对象，反向的调用add()方法，添加数据
    		Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
    		//获取add()方法
    		Method m = listClass.getMethod("add", Object.class);
    		//调用add()方法
    		m.invoke(strList, 100);
    		
    		//遍历集合
    		for(Object obj : strList){ 
    			System.out.println(obj);
    		}
    	}
    }

控制台输出：  
aaa  
bbb  
100

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/1bdbbc69cc5045298a1c8e6f49cad84e.png