目录
一、类加载器
1.1 类加载概述
类加载：当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化。
类的加载- 就是指将class文件读入内存，并为之创建一个 java.lang.Class 对象
- 任何类被使用时，系统都会为之建立一个 java.lang.Class 对象
类的连接- 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
- 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
- 解析阶段：将类的二进制数据中的符号引用替换为直接引用
类的初始化- 在该阶段，主要就是对类变量进行初始化
1.2 类加载器
1.2.1 作用
作用：负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。
1.2.2 java内置的类加载器
Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null ，并且没有父nullPlatform class loader：平台类加载器可以看到所有平台类 ，平台类包括由平台类加载器或其祖先定义的JavaSE平台API，其实现类和JDK特定的运行时类System class loader：它也被称为应用程序类加载器 ，与平台类加载器不同。 系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstra
二、反射
2.1 反射概述
反射：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展。
Class类对象概述：
- Class 类的实例表示正在运行的 Java 应用程序中的类和接口
- Class 没有公共构造方法
- 每个类都只会加载一次，每个类型的Class对象是唯一的
2.2 获取Class类对象的三种方式
类名.class属性对象名.getClass()方法Class.forName(全类名)方法
Class常用方法：
String getName()：获取类的完全限定名Package getPackage()：获取类的包
示例
public class Student {
//成员变量：一个私有，一个默认，一个公共
private String name;
int age;
public String address;
//构造方法：一个私有，一个默认，两个公共
public Student() {}
private Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
//成员方法：一个私有，四个公共
private void function() {
System.out.println("function");
}
public void method1() {
System.out.println("method");
}
public void method2(String s) {
System.out.println("method:" + s);
}
public String method3(String s, int i) {
return s + "," + i;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
//使用类的class属性来获取该类对应的Class对象
Class<Student> c1 = Student.class;
System.out.println(c1);
Class<Student> c2 = Student.class;
System.out.println(c1 == c2);
System.out.println("--------");
//调用对象的getClass()方法，返回该对象所属类对应的Class对象
Student s = new Student();
Class<? extends Student> c3 = s.getClass();
System.out.println(c1 == c3);
System.out.println("--------");
//使用Class类中的静态方法forName(String className)
Class<?> c4 = Class.forName("com.entity.Student");
System.out.println(c1 == c4);
}
}
2.3反射获取类的各个部分
2.3.1 反射获取类的构造方法
Constructor<?>[] getConstructors()：返回所有公共构造方法对象的数组Constructor<?>[] getDeclaredConstructors()：返回所有构造方法对象的数组Constructor getConstructor(Class<?>... parameterTypes)：返回单个公共构造方法对象Constructor getDeclaredConstructor(Class<?>...parameterTypes)：返回单个构造方法对象
示例：
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchMethodException, IllegalAccessException, InvocationTargetException,InstantiationException {
//获取Class对象
Class<?> c = Class.forName("com.entity.Student");
Constructor<?>[] cons = c.getDeclaredConstructors();
for(Constructor con : cons) {
System.out.println(con);
}
System.out.println("--------");
//Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
//参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
Constructor<?> con = c.getConstructor();
//Constructor提供了一个类的单个构造函数的信息和访问权限
//T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
Object obj = con.newInstance();
System.out.println(obj);
}
}
2.3.2 反射创建对象的方法
T newInstance(Object...initargs)：根据指定的构造方法创建对象
实例：
public class ReflectDemo02 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchMethodException,IllegalAccessException, InvocationTargetException,InstantiationException {
//获取Class对象
Class<?> c = Class.forName("com.entity.Student");
//public Student(String name, int age, String address)
//Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor<?> con = c.getConstructor(String.class, int.class,String.class);
//基本数据类型也可以通过.class得到对应的Class类型
//T newInstance(Object... initargs)
Object obj = con.newInstance("天天", 30, "西安");
System.out.println(obj);
}
}
2.3.3 反射获取成员变量的方法
Field[] getFields()：返回所有公共成员变量对象的数组Field[] getDeclaredFields()：返回所有成员变量对象的数组Field getField(String name)：返回单个公共成员变量对象Field getDeclaredField(String name)：返回单个成员变量对象
实例：
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException, NoSuchMethodException, IllegalAccessException,InvocationTargetException, InstantiationException {
//获取Class对象
Class<?> c = Class.forName("com.entity.Student");
//Field[] getFields() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段
//Field[] getDeclaredFields() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段
//Field[] fields = c.getFields();
Field[] fields = c.getDeclaredFields();
for(Field field : fields) {
System.out.println(field);
}
System.out.println("--------");
//Field getField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段
//Field getDeclaredField(String name) 返回一个 Field对象，该对象反映由该Class对象表示的类或接口的指定声明字段
Field addressField = c.getField("address");
//获取无参构造方法创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// obj.addressField = "西安";
//Field提供有关类或接口的单个字段的信息和动态访问
//void set(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值
addressField.set(obj,"西安"); //给obj的成员变量addressField赋值为西安
System.out.println(obj);
}
}
2.3.4 Field类给成员变量赋值
void set(Object obj,Object value)：给obj对象的成员变量赋值为valueObject get(Object obj)：获取指定的成员变量的值setAccessible(true)：暴力反射
示例：
public class ReflectDemo02 {
public static void main(String[] args) throws Exception {
//获取Class对象
Class<?> c = Class.forName("com.entity.Student");
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
Field nameField = c.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(obj, "天天");
System.out.println(obj);
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj,30);
System.out.println(obj);
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true);
addressField.set(obj,"西安");
System.out.println(obj);
}
}
2.3.5 反射获取成员方法
Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的Method getMethod(String name, Class<?>...parameterTypes)：返回单个公共成员方法对象Method getDeclaredMethod(String name, Class<?>...parameterTypes)：返回单个成员方法对象
实例：
public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
//获取Class对象
Class<?> c = Class.forName("com.entity.Student");
Method[] methods = c.getDeclaredMethods();
for(Method method : methods) {
System.out.println(method);
}
System.out.println("--------");
Method m = c.getMethod("method1");
//获取无参构造方法创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// obj.m();
//在类或接口上提供有关单一方法的信息和访问权限
//Object invoke(Object obj, Object... args) 在具有指定参数的指定对象上调用此方法对象表示的基础方法
//Object：返回值类型
//obj：调用方法的对象
//args：方法需要的参数
m.invoke(obj);
}
}
2.3.6 Method类用于执行方法的方法
Object invoke(Object obj,Object... args)：调用obj对象的成员方法，参数是args,返回值是Object类型
实例：
public class ReflectDemo02 {
public static void main(String[] args) throws Exception {
//获取Class对象
Class<?> c = Class.forName("com.itheima_02.Student");
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
Method m1 = c.getMethod("method1");
m1.invoke(obj);
Method m2 = c.getMethod("method2", String.class);
m2.invoke(obj,"天天");
Method m3 = c.getMethod("method3", String.class, int.class);
Object o = m3.invoke(obj, "天天", 30);
System.out.println(o);
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
2.3.7 反射案例
2.3.7.1 越过泛型检查
public class ReflectTest01 {
public static void main(String[] args) throws Exception {
//创建集合
ArrayList<Integer> array = new ArrayList<Integer>();
// array.add(10);
// array.add(20);
// array.add("hello");
Class<? extends ArrayList> c = array.getClass();
Method m = c.getMethod("add", Object.class);
m.invoke(array,"hello");
m.invoke(array,"world");
m.invoke(array,"java");
System.out.println(array);
}
}
2.3.7.2 运行配置文件中指定类的指定方法
public class ReflectTest02 {
public static void main(String[] args) throws Exception {
//加载数据
Properties prop = new Properties();
FileReader fr = new FileReader("myReflect\\class.txt");
prop.load(fr);
fr.close();
//获取类的完全限定名和方法名
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
//通过反射来创建实例对象
Class<?> c = Class.forName(className);
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
Method m = c.getMethod(methodName);
m.invoke(obj);
}
}
1039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
