文章目录
说明:反射机制这一块内容看的是b站上尚硅谷宋红康老师的课程,b站视频链接,其中P636~665是反射机制相关的讲解
反射机制
一、反射机制概述
1、反射机制概述
反射是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
加载完类后,在堆内存的方法区就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。
正常方式:引入需要的“包类”的名称—通过new实例化—取得实例化对象
反射方式:实例化对象—getClass()方法—得到完整的“包类”名称
2、补充:动态语言vs静态语言
动态语言:一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进,已有的函数可以被删除或是其结构上的变化。即在运行时代码可以根据某些条件改变自身结构。如:Object-C、C#、JavaScript、PHP、Python。
静态语言:运行时结构不可变的语言,如Java、C、C++。Java具有一定的动态性,可以利用反射机制、字节码操作获得类似动态语言的特性。
3、反射机制的功能
-
在运行时判断任意一个对象所属的类
-
在运行时构造任意一个类的对象
-
在运行时判断任意一个类所具有的成员变量和方法
-
在运行时获取泛型信息
-
在运行时调用任意一个对象的成员变量和方法
-
在运行时处理注解
-
生成动态代理
4、反射相关的主要API
-
java.lang.Class 代表一个类
-
java.lang.reflect.Method 代表类的方法
-
java.reflect.Field 代表类的成员变量
-
java.lang.reflect.Constructor 代表类的构造器
…
二、理解Class类并获取Class实例
1、反射前后的实例对比
package org.test3;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* Created by luyangsiyi on 2020/2/15
*/
public class ReflectionTest {
//反射之前,对于Person类的操作
@Test
public void test1(){
//1.创建Person类的对象
Person p1 = new Person("Tom",21);
//2.通过对象,调用其内部的属性、方法
p1.age = 10;
System.out.println(p1.toString());
p1.show();
//在Person类外部,是不可以通过Person类的对象调用其内部私有结构
//比如:name、showNation()以及私有的构造器
}
//反射之后,对于Person类的操作
@Test
public void test2() throws Exception {
Class clazz = Person.class;
//1.通过反射,创建Person类的对象
Constructor cons = clazz.getConstructor(String.class,int.class);
Person p = (Person) cons.newInstance("Tom",21);
System.out.println(p.toString());
//2.通过反射,调用对象指定的属性、方法
//调用属性
Field age = clazz.getDeclaredField("age");
age.set(p,10);
System.out.println(p.toString());
//调用方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p);
//3.通过反射,可以调用Person类的私有结构。比如:私有的构造器、方法、属性
//调用私有的构造器
Constructor cons1 = clazz.getDeclaredConstructor(String.class);
cons1.setAccessible(true);
Person p1 = (Person) cons1.newInstance("Jerry");
System.out.println(p1);
//调用私有的属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"Alice");
System.out.println(p1);
//调用私有的方法
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
showNation.setAccessible(true);
String nation = (String)showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
System.out.println(nation);
}
}
对应的User类:
package org.test3;
/**
* Created by luyangsiyi on 2020/2/15
*/
public class Person {
private String name;
public int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
private Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void show(){
System.out.println("你好,我是一个人");
}
private String showNation(String nation){
System.out.println("我的国籍是:"+nation);
return nation;
}
}
2、反射vs封装
Q1:通过直接new的方式或反射的方式都可以调用公共的结构,开发中到底用哪个?
A1:直接new的方式。
Q2:反射机制与面向对象中的封装是不是矛盾的?如何看待这两个技术?
A2:不矛盾。封装表示建议你使用哪些方法,反射解决的是你能不能调用的问题。
3、Class类的理解
(1)关于java.lang.Class类的加载过程的理解:
程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾)。
接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中,此过程就称为类的加载。
加载到内存中的类,我们称为运行时类,此运行时类,就作为Class的一个实例。即,Class的实例就对应着一个运行时类。
(2)加载到内存中的运行时类,会缓存一定的时间。在此时间内,可以通过不同的方式来获取此运行时类。
(3)哪些类型可以用Class对象
-
class:外部类,成员,局部内部类,匿名内部类
-
interface:接口
-
[]:数组(只要元素类型与维度一样,就是同一个Class)
-
enum:枚举
-
annotation:注解
-
primitive type:基本数据类型
-
void
4、获取Class实例的方式
//获取Class的实例的方式
@Test
public void test3() throws Exception {
//方式一:调用运行时类的属性:.class
Class clazz1 = Person.class;
System.out.println(clazz1);
//class org.test3.Person
//方式二:通过运行时类的对象
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
//class org.test3.Person
//方式三(常用):调用Class的静态方法:forName(String classPath)
Class clazz3 = Class.forName("org.test3.Person");
System.out.println(clazz3);
//class org.test3.Person
System.out.println(clazz1==clazz2);//true
System.out.println(clazz1==clazz3);//true
//方式四(了解即可):使用类的加载器
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("org.test3.Person");
System.out.println(clazz4);//class org.test3.Person
System.out.println(clazz1==clazz4);//true
}
三、类的加载与ClassLoader的理解
1、类的加载过程
当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化。
(1)类的加载(Load)
将类的class文件读入内存,并为之创建一个java.lang.Class对象,此过程由类加载器完成。
(2)类的链接
将类的二进制数据合并到JRE(Java Runtime Environment)中。
(3)类的初始化
JVM负责对类进行初始化。
2、ClassLoader
类加载器的作用:将class文件字节码内容加载到内存中,并将这些静态数据转化为方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口。
类缓存:标准的JavaSE类加载器可以按照要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间,不过JVM垃圾回收机制可以回收这些Class对象。
(1)使用ClassLoader加载配置文件
@Test
public void test() throws Exception {
Properties properties =