java基础之反射
一、类加载器
1.类加载
当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过类的加载,类的连接,类的初始化这三个步骤来对类进行初始化。如果不出现意外情况,JVM将会连续完成这三个步骤,所以有时也把这三个步骤统称为类加载或者类初始化。
类的加载:
- 就是指将class文件读入内存, 并为之创建一个 java.lang.Class对象
- 任何类被使用时,系统都会为之建立-个java.lang.Class对象
类的连接:
- 验证阶段:用于检验被加载的类是否有正确的内部结构,并和其他类协调一致
- 准备阶段:负责为类的类变量分配内存,并设置默认初始化值
- 解析阶段:将类的二进制数据中的符号引|用替换为直接引|用
类的初始化:
初始化是对类变量进行的
其步骤:
- 假如类还未被加载和连接,则程序先加载并连接该类
- 假如该类的直接父类还未被初始化,则先初始化其直接父类
- 假如类中有初始化语句,则系统依次执行这些初始化语句
注:在执行第二个步骤的时候,系统会对直接父类初始化步骤,并且也会遵循以上三个步骤。
由此看出,每次初始化,第一个被初始化的都是java.lang.Object。
类初始化的时机:
- 创建类的实例
- 调用类的类方法
- 访问类或者接口的类变量,或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
2.类加载器
1.类加载器的作用
- 负责将.class文件加载到内存中,并为之生成对应的java.lang.Class对象
- 虽然我们不用过分关心类加载的机制,但是了解它可以更好理解程序是怎么运行的。
JVM的类加载机制
-
全盘负责:当一个类加载器负责加载某个Class时,该Class所依赖的和引用的其他Class也将由该类加载器负责载入,除非显示使用另外一个类加载器来载入
-
父类委托:当一个类加载器负责加载某个Class时,先让父类加载器试图加载该Class,只有在父类加载器无法加载该类时,才尝试从自己的类路径中加载该类
-
缓存机制:保证所有加载过的Class都会被缓存,当程序需要使用某个Class对象时, 类加载器先从缓存区中搜索该Class,只有当缓存区中不存在该Class对象时,系统才会读取该类对应的二进制数据,并将其转换成Class对象,存储到缓存区
2.加载器和常见方法
ClassLoader:是负责加载类的对象
Java运行时具有以下内置类加载器
- Bootstrap class loader:它是虚拟机的内置类加载器,通常表示为null,并且没有父null
- Platform class loader:平台类加载器可以看到所有平台类,平台类包括由平台类加载器或其祖先定义的Java SE平台API,
其实现类和JDK特定的运行时类 - System class loader:它也被称为应用程序类加载器,与平台类加载器不同。系统类加载器通常用于定义应用程序类路径,模块路径和JDK特定工具上的类
- 类加载器的继承关系: System的父加载器为Platform,而Platform的父加载器为Bootstrap
ClassLoader中的两个方法:
- static ClassLoader getSystemClassLoader():返回用于委派的系统类加载器
- ClassLoader getParent):返回父类加载器进行委派
//显示类加载器
public class ClassLoderDemo {
public static void main(String[] args) {
// static ClassLoader getSystemClassLoader():返回用于委派的系统类加载器
ClassLoader c1 = ClassLoader.getSystemClassLoader();
System.out.println(c1);//AppClassLoader
// ClassLoader getParent):返回父类加载器进行委派
ClassLoader c2 = c1.getParent();
System.out.println(c2);//ExtClassLoader ---jdk8返回的是这个
//PlatformClassLoader ---jdk9返回这个
ClassLoader c3 = c2.getParent();
System.out.println(c3);//null
}
}
二、反射
1.引入概念
反射是指什么?
首先引入一个例子,人在走过x光机的时候,我们能扫描出一个人的模样出来。而这个被扫描的图像可以透射出原来的人在哪些部分坏了,那些地方不好,从而可以指导我们到原来那个人那里进行手术操作。
在我们程序中也是这样,
左边两个类可以看作是人,而这个类加载器就是一台x光机,右边的那个东西就是我们x光机照出来的。类的所有的成员变量,构造方法成员方法都是通过这个Class来使用的。
所以其实我们平时使用类的时候,不是去使用这个类本身,而是通过反射这个方法把类的东西都交给了这个class这个东西来使用。
2.Java反射机制概述:
**Java反射机制:**是指在运行时去获取一个类的变量和方法信息。 然后通过获取到的信息来创建对象,调用方法的一种机制。由于这种动态性,可以极大的增强程序的灵活性,程序不用在编译期就完成确定,在运行期仍然可以扩展
获取Class类的对象:
我们要想通过反射去使用一个类,首先我们要获取到该类的字节码文件对象,也就是类型为Class类型的对象
这里我们提供三种方式获取Class类型的对象
- 使用类的class属性来获取该类对应的Class对象。 举例: Student.class将 会返回Student类对应的Class对象
- 调用对象的getClass(方法, 返回该对象所属类对应的Class对象
该方法是Object类中的方法,所有的Java对象都可以调用该方法 - 使用Class类中的静态方法forName(String className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径,也就是完整包名的路径
//获取class对象
public class ClassLoderDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
//使用类的class属性来获取该类对应的Class对象。 举例: Student.class将 会返回Student类对应的Class对象
Class<ClassStudent> c1 = ClassStudent.class;
System.out.println(c1);
//class com.lys.heima.javaSEjichu.ClassLoder.ClassStudent
Class<ClassStudent> c2 = ClassStudent.class;
System.out.println(c1==c2);
//调用对象的getClass(方法, 返回该对象所属类对应的Class对象
//该方法是Object类中的方法,所有的Java对象都可以调用该方法
Class<? extends ClassStudent> c3 = new ClassStudent().getClass();
System.out.println(c1==c3);
//使用Class类中的静态方法forName(String className),该方法需要传入字符串参数,
// 该字符串参数的值是某个类的全路径,也就是完整包名的路径
Class<?> C4 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
System.out.println(c1==C4);
}
}
/*
结果:
class com.lys.heima.javaSEjichu.ClassLoder.ClassStudent
true
true
true
*/
3.反射获取构造方法并使用
Class类中用于获取构造方法的方法:
- Constructor<?>()getConstructors0:
- 返回所有公共构造方法对象的数组
- Constructor<?>() getDeclared onstructors0:
- 返回所有构造方法对象的数组
- Constructor getConstructor(Class<?>… parameterTypes):
- 返回单个公共构造方法对象
- Constructor getDeclaredConstructor(Class <?> … parameterTypes):
- 返回单个构造方法对象
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
//通过反射获取构造方法
public class classLoderDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
//获取公共构造方法集
Constructor<?>[] cons1 = c1.getConstructors();
for (Constructor c : cons1) {
System.out.println(c);
}
//结果:
//public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String,int,java.lang.String)
//public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()
System.out.println("----------------------------------------");
//获取所有构造方法集
Constructor<?>[] cons2 = c1.getDeclaredConstructors();
for (Constructor c : cons2) {
System.out.println(c);
}
//结果:
//public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String,int,java.lang.String)
//com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String,int)
//private com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String)
//public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()
System.out.println("----------------------------------------");
//获取单个公共构造方法;
Constructor<?> con1 = c1.getConstructor();
System.out.println(con1);
//public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()
System.out.println("----------------------------------------");
//获取单个构造方法:
Constructor<?> con2 = c1.getDeclaredConstructor();
System.out.println(con2);
//public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()
System.out.println("----------------------------------------");
//通过获取到的构造方法来创建对象
Object newture = con1.newInstance();//若要调用带参构造方法,括号需要写入参数。
System.out.println(newture);
//ClassStudent{name='null', age=0, address='null'} ;由于classStudent类里重写了tostring方法,所以这里以这种方式输出了。
System.out.println("----------------------------------------");
//通过获取到的公共带参构造方法创建对象。
Constructor<?> con3 = c1.getConstructor(String.class, int.class, String.class);//参数根据顺序排列。要用参数的.class
Object newInstance = con3.newInstance("陈奕迅", 45, "香港");
System.out.println(newInstance);
//ClassStudent{name='陈奕迅', age=45, address='香港'}
}
}
基础数据类型也可以通过.Class得到对应的Class类型
通过反射利用私有构造方法创建对象:
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//反射获取私有构造方法
public class classLoderDemo3 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException {
Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
Constructor<?> con1 = c1.getDeclaredConstructor(String.class);
//使用暴力反射。将其访问检查取消
con1.setAccessible(true);//true时表示取消检查
Object newInstance = con1.newInstance("张家辉");
//.IllegalAccessException,私有构造方法无法直接使用。
System.out.println(newInstance);
//ClassStudent{name='张家辉', age=0, address='null'} 通过暴力反射创建成功。
}
}
public void setAccessible(boolean flag):值为true ,取消访问检查。
4.通过反射获取成员变量
Class类中用于获取成员变量的方法
- Field[ getFields():返回所有公共成员变量对象的数组
- Field[ getDeclaredFields():返回所有成员变量对象的数组
- Field getField(String name):返回单个公共成员变量对象
- Field getDeclaredField(String name):返回单个成员变量对象
Field类中用于给成员变量赋值的方法
- void set(Object obj, Object value):给obj对象的成员变量赋值为value
package com.lys.heima.javaSEjichu.ClassLoder;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
//反射获取成员变量并使用
public class classLoderDemo4 {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException, NoSuchMethodException, InvocationTargetException,
InstantiationException, IllegalAccessException {
Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
//获取所有成员变量
Field[] fs1 = c1.getDeclaredFields();
for ( Field f : fs1 ){
System.out.println(f);
}
//private java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.name
//int com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.age
//public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.address
System.out.println("--------------------");
//获取公共成员变量集
Field[] fs2 = c1.getFields();
for ( Field f : fs2 ){
System.out.println(f);
}
//获取某个公共成员变量
Field address = c1.getField("address");
//public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.address
System.out.println(address);
//获取任意成员变量
Field age = c1.getDeclaredField("age");
System.out.println(age);
//int com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.age
//创建一个对象并为其赋值
Constructor<?> con1 = c1.getConstructor();
Object obj = con1.newInstance();
address.set(obj,"香港");
System.out.println(obj);//ClassStudent{name='null', age=0, address='香港'}
age.set(obj,15);
System.out.println(obj);//ClassStudent{name='null', age=15, address='香港'}
Field name = c1.getDeclaredField("name");
name.setAccessible(true);//暴力反射,取消访问检查
name.set(obj,"陈奕迅");
System.out.println(obj);//ClassStudent{name='陈奕迅', age=15, address='香港'}
System.out.println(name);/*private java.lang.String
com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.name*/
}
}
5.获取成员方法
Class类中用于获取成员方法的方法
- Method[] getMethods():返回所有公共成员方法对象的数组,包括继承的
- Method[] getDeclaredMethods():返回所有成员方法对象的数组,不包括继承的
- Method getMethod(String name, Class <?>… parameterTypes) :返回单个公共成员方法对象
- Method getDeclaredMethod(String name, Class<?>… parameterTypes):返回单个成员方法对象
Method类中用于调用成员方法的方法
- Object invoke(Object obj, Object… args):调用obj对象的成员方法,参数是args,返回值是Object类型。
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//获取成员方法
public class classLoderDemo5 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
//获取公共方法集
Method[] ms1 = c1.getMethods(); //包含本类公共方法和继承的超类和超接口方法。
for ( Method m:ms1){
System.out.println(m);
}//结果:
//public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.toString()
//public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method1()
//public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method2(java.lang.String)
//public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method3(java.lang.String,int)
//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 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()
System.out.println("------------------");
//获取所有方法集
Method[] ms2 = c1.getDeclaredMethods();//包含本来所以方法,但没有继承来的方法。
for (Method m:ms2){
System.out.println(m);
}
//public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.toString()
//private void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.function()
//public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method1()
//public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method3(java.lang.String,int)
//public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method2(java.lang.String)
//获取某个公共方法
Method m1 = c1.getMethod("method1");
System.out.println(m1);
Method m2 = c1.getMethod("method3", String.class, int.class);
//获取任一方法
Method m3 = c1.getDeclaredMethod("function");
System.out.println(m2);
System.out.println("-----------");
//创建对象,并调用方法
Constructor<?> con1 = c1.getConstructor();
Object obj = con1.newInstance();
m1.invoke(obj); //参数是对象,这样表示是m1被obj对象使用。运行结果:method
System.out.println("-----------");
System.out.println(m2.invoke(obj,"张敬轩",15));//张敬轩,15
System.out.println("-----------");
m3.setAccessible(true); //设置访问检查取消
m3.invoke(obj); //function
}
}
6.反射练习:
1.有一个ArrayList集合,要在这个集合添加一个字符串数据。
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
//在integer集合存字符串
public class ClassLoderDemo6 {
public static void main(String[] args) throws NoSuchMethodException,
InvocationTargetException, InstantiationException, IllegalAccessException {
ArrayList<Integer> a = new ArrayList<>();
a.add(10);
Class<? extends ArrayList> c1 = a.getClass();
Method m = c1.getMethod("add", Object.class);
m.invoke(a,"hello");
System.out.println(a);
}
}
2.通过配置文件运行类中方法:
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
//"com.lys.heima.javaSEjichu.ClassLoder.ClassStudent"
public class ClassLoderDemo7 {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
Properties pro = new Properties();//数据安全的map
FileReader fr = new FileReader("wenjian.txt");//io流对象去读取文件数据
pro.load(fr);//把数据传给这个集合
fr.close();//取完数据关闭资源
String className = pro.getProperty("className"); //根据键取值
//System.out.println(className);
String methodName = pro.getProperty("methodName"); //根据键取值
//System.out.println(methodName);
//通过反射使用
Class<?> c1 = Class.forName(className); //根据值创建class对象
Object obj = c1.newInstance(); //根据类创建新对象。
Method method = c1.getMethod(methodName);//根据值创建方法对象
method.invoke(obj); //调用方法
}
}
/*
结果:
method
*/
wenjian.txt:
className=com.lys.heima.javaSEjichu.ClassLoder.ClassStudent
methodName=method1
以上代码其实是根据这个wenjian.txt里面的键值对来反射出对象并进行操作的,
这意味着,我只需要更改文件里的内容,就可以让我同一份代码完成不同的操作。
这就体现出了反射的灵活性了。
最后总结:到底什么是反射?反射就是将类的各个部分(成员,方法,构造器)封装成对象。