Java反射笔记（近万字超详细讲解）

package com.hspdeu.reflection;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();
        String method = properties.get("method").toString();
        //(1)加载类，返回Class类型的对象aClass
        Class aClass = Class.forName(classfullpath);
        //(2)通过 aClass 得到你加载的类 com.hsaedu.cat
        Object o = aClass.newInstance();
        //(3)通过 aClass 得到你加载的类 com.hsaedu.cat 的Method “hi”的方法对象
        // 在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = aClass.getMethod(method);
        //（4）通过Method1 调用方法：即通过方法对象来实现调用方法。
        method1.invoke(o);
    }
}

注意：通过此方法构建的对象，符合开闭原则，只需要修改配置文件不需要修改源程序。

Java反射界面原理图：

Class类

java.langClass：代表一个类，Class对象表示某个类加载后在堆中的对象。

java.lang.reflect.Method：代表类的方法。Method对象表示某个类的方法。

java.lang.reflect.Field：代表类的成员变量。Field对象表示某个类的成员变量。

java.lang.reflect.Construtor：代表类的构造方法。Constructor对象表示一个构造器。

基本介绍

Class也是类，因此也继承Object类
Class类对象不是new出来的，而是系统创建的
对于某个类的Class类对象，在内存中只有一份，因此类只加载一次
每个类的实例都会记得自己是由那个Class实例所生成
通过Class可以完整地得到一个类的完整结构，通过一系列API
Class 对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（方法代码、变量名、方法名、访问权限等等）

Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance（）	调用缺省构造函数，返回该Class对象的一个实例
getName（）	返回此Class对象所表示的实体名称
Class getSuperClass（）	返回当前Class对象的父类的Class对象
Class [] getInterface（）	获取当前Class对象的接口
ClassLoader getClassLoader（）	返回该类的类加载器
Class getSuperclass（）	返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors（）	返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields（）	返回Field对象的一个数组
Method getMethod （String name，Clas.. paramTypes）	返回一个Methed对象此对象的形参类型为paramType

实例代码

 String classPath = "com.hspedu.Car";
        //1: 获取到Car类 对应 Class对象
        Class<?> aClass = Class.forName(classPath);
        //2.输出aClass
        System.out.println(aClass);//显示aClass对象，是那个类的Class对象 com.hspedu.Car
        System.out.println(aClass.getClass());//输出aClass运行类型 java.lang.Class
        //3.得到包名
        System.out.println(aClass.getPackage().getName());
        //4.得到全类名
        System.out.println(aClass.getName());
        //5.通过aClass创建对象实例
        Object o = aClass.newInstance();
        Car car = new Car();
        //6.通过反射获取属性
        Field field = aClass.getField("bread");//私有属性会报错
        System.out.println(field.get(o));
        //7.通过反射给属性赋值
        field.set(o,"长城炮");
        System.out.println(field.get(o));
        //8.获取所有的属性
        Field[] fields = aClass.getFields();
        for (Field f : fields){
            System.out.println(f.getName());
        }

类图：

例题：


        //java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量
        //得到name字段
        Field field = aClass.getField("pName");
        System.out.println(field.get(o).toString());//传统写法 对象.成员变量, 反射 ： 成员变量对象.get(对象)

        //java.lang.reflect.Constructor: 代表类的构造方法，Constructor对象表示构造器
        Constructor constructor = aClass.getConstructor();//()中可以指定构造器参数类型，返回无参构造器
        System.out.println(constructor);

反射调用优化：

Method 和 Field、Constructor对象都有serAccessible()方法。
setAccessible作用是启动和禁用访问安全检查的开关。
参数值为true表示、反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查。

类加载（ClassLoader）

基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现动态加载。

静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错，降低了依赖性

类加载时机

当创建对象时（new）
当子类被加载时，父类也加载
调用类中的静态成员时
通过反射

类加载图

类加载五个阶段

加载 —— 验证 —— 准备 —— 解析 —— 初始化

加载阶段

JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包、甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象。

验证阶段

目的是为了保证Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全。
包括：文件格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证。
可以考虑使用 -Xverify：none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。

准备阶段

JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如0、0L、null、false等）。这些变量所使用的内除都将在方法区中进行分配。

解析阶段

虚拟机将常量池的符号引用替换为直接引用的过程。

初始化阶段

到初始化阶段，才真正开始执行类中定义的java程序代码，此阶段是执行<clinit>()方法的过程
<clinit>()方法是由编译器按语句在源文件中出现的顺序，一次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时区初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。

lodaClass()

Class类常用方法

Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance（）	调用缺省构造函数，返回该Class对象的一个实例
getName（）	返回此Class对象所表示的实体名称
Class getSuperClass（）	返回当前Class对象的父类的Class对象
Class [] getInterface（）	获取当前Class对象的接口
ClassLoader getClassLoader（）	返回该类的类加载器
Class getSuperclass（）	返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors（）	返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields（）	返回Field对象的一个数组
Method getMethod （String name，Clas.. paramTypes）	返回一个Methed对象此对象的形参类型为paramType

实例代码

 String classPath = "com.hspedu.Car";
        //1: 获取到Car类 对应 Class对象
        Class<?> aClass = Class.forName(classPath);
        //2.输出aClass
        System.out.println(aClass);//显示aClass对象，是那个类的Class对象 com.hspedu.Car
        System.out.println(aClass.getClass());//输出aClass运行类型 java.lang.Class
        //3.得到包名
        System.out.println(aClass.getPackage().getName());
        //4.得到全类名
        System.out.println(aClass.getName());
        //5.通过aClass创建对象实例
        Object o = aClass.newInstance();
        Car car = new Car();
        //6.通过反射获取属性
        Field field = aClass.getField("bread");//私有属性会报错
        System.out.println(field.get(o));
        //7.通过反射给属性赋值
        field.set(o,"长城炮");
        System.out.println(field.get(o));
        //8.获取所有的属性
        Field[] fields = aClass.getFields();
        for (Field f : fields){
            System.out.println(f.getName());
        }

获取类对象的六种方式

编译阶段： Class.forName（）
加载阶段：类.class
运行阶段：对象.getClass（）
通过类加载器获取： ClassLoade

        //1.Class.forName()
        String classAllPath = "com.hspedu.Car";
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2.类名.class,应用场景：用于参数的传递
        Class cls2 = Car.class;
        System.out.println(cls2);

        //3.对象.getClass(),应用场景，有对象实例
        Car car = new Car();
        System.out.println(car.getClass());

        //4.通过类加载器, 应该场景
        //（1）先得到类加载器 Car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过Car的类加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass(classAllPath);

        System.out.println(cls4);
        //5.基本数据类型的Class类对象
        Class<Integer> integerClass = int.class;
        System.out.println(integerClass);
        
        //基本数据类型的包装类的Class类对象
        Class<Integer> type = Integer.TYPE;
        System.out.println(type);

获取了对象，就是获取了这个类中的所有定义。

可以动态获取类中中的内容，对这个类的对象进行操作

反射获取类的结构信息

java.lang.Class类常用方法

getName	获取全类名
getSimpleName	获取简单类名
getFields	获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields	获取本类中所有属性
getMethods	获取本类和父类所有的方法（public）
getDeclareMethods	获取本类中所有方法
getConstructors	获取所有public修饰的构造器，包含本类
getDeclareConstructors	获取本类中所有构造器
getPackage	以Package形式返回包信息
getSuperCLass	以Class形式返回父类信息
getInterfaces	以Class[]形式返回接口信息
getAnnotations	以Annotation[] 形式返回注解信息

java.lang.reflect.Field常用方法

getModifiers

以int形式返回修饰符

（说明：默认修饰符是 0，public 是 1，private 是 2 protected 是 4 ，static 是 8 ，final 是 16）public static 返回 1+8=9

getType

该属性的类型

java.lang.reflect.Method常用方法

getModifiers	以int形式返回修饰符（说明：默认修饰符是 0，public 是 1，private 是 2 protected 是 4 ，static 是 8 ，final 是 16）public static 返回 1+8=9
getReturnType	以Class形式获取返回类型
getName	返回方法名
getParameterTypes	以Class[]返回参数类型数组

java.lang.reflect.Constructor常用方法

getParameterTypes	以Class[]返回参数类型数组
getName	返回构造器名字
getModifiers	以int形式返回修饰符

通过反射创建对象

方式一：调用类中的public修饰的无参构造器
方式二：调用类中的指定构造器
Class类相关方法

1. newInstance：调用类中的无参构造器，获取对应的对象
2. getConstrutor（Class...clazz）:根据参数列表，获取对应的public构造对象
3. getDecalaredConstrctor（Class...clazz）:根据参数列表，获取对应的构造对象

Construtor类相关方法

1. setAccessible：暴破（暴力破解），使用反射可以访问private构造器
2. newInstance（Object...obj）:调用构造器

演示案列

package com.hspedu.reflection;

import java.lang.reflect.Constructor;

public class RefluecCreateCls {
    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("com.hspedu.reflection.User");
        Object o = aClass.newInstance();
        System.out.println(o);
        Constructor<?> constructor = aClass.getConstructor(String.class);

        Object o1 = constructor.newInstance("张张");
        System.out.println(o1);

        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);//暴破，使用反射可以访问private构造器
        Object o2 = declaredConstructor.newInstance("王五", 20);
        System.out.println(o2);
    }
}
class User{


    private int age = 0;
    private String name = "李李";

    public User(){}
    public User(String name){
        this.name = name;
    }
    private User(String name ,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

暴破演示

package com.hspedu.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class RefluecCreateCls {
    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("com.hspedu.reflection.Student");
        Object o = aClass.newInstance();
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"张张");//静态成员可以把对象写成null
        System.out.println(name.get(o));//null也是同一个结果
    }
}
class Student{
    public int age;
    private static String name;
    public Student(){

    }
    @Override
    public String toString() {
        return "Student{" +
                "name" + name +
                "age=" + age +
                '}';
    }
}

Java中实例化构造对象的方式

new
克隆
反序列化
反射

package com.easyc;

import java.lang.reflect.Field;

public class EasyC {
	//模拟网络接口或者数据库数据
	public static Object[] arr= {12,"zhangsan",22};
	
	public static  Object getObj(Class c,Object[] arr) {
		//判断c是否为空
		Object result=null;
		try {
			result=c.newInstance();
			Field f1=c.getDeclaredField("id");
			f1.setAccessible(true);
			f1.set(result, arr[0]);
			Field f2=c.getDeclaredField("name");
			f2.setAccessible(true);
			f2.set(result, arr[1]);
			Field f3=c.getDeclaredField("age");
			f3.setAccessible(true);
			f3.set(result, arr[2]);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	public static void main(String[] args) {
		try {
			Class c=Class.forName(args[0]);
			Object obj=getObj(c,arr);
			System.out.println(obj);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class ObjC{
	private int id;
	private String name;
	private int age;
	
	public String toString() {
		return "ObjC [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}