Java反射

一、类加载器
1.类的加载
当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三步来实现对这个类进行初始化。
①加载 
就是指将class文件读入内存,并为之创建一个Class对象。
任何类被使用时系统都会建立一个Class对象
②连接
验证 是否有正确的内部结构,并和其他类协调一致
准备 负责为类的静态成员分配内存,并设置默认初始化值
解析 将类的二进制数据中的符号引用替换为直接引用
③初始化 
就是我们以前讲过的初始化步骤
2.类初始化时机
①创建类的实例
②类的静态变量,或者为静态变量赋值
③类的静态方法
④使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
⑤初始化某个类的子类
⑥直接使用java.exe命令来运行某个主类
3.类加载器
负责将.class文件加载到内在中,并为之生成对应的Class对象
4.类加载器的组成
①Bootstrap ClassLoader 根类加载器
也被称为引导类加载器,负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
②Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录
③System ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件,以及classpath环境变量所指定的jar包和类路径。
二、反射
1.概述
JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。定义一个bean对象:
public class Person {
	//成员变量
	public String name;
	public int age;
	private String address;

	//构造方法
	public Person() {
		System.out.println("空参数构造方法");
	}

	public Person(String name) {
		this.name = name;
		System.out.println("带有String的构造方法");
	}
	//私有的构造方法
	private Person(String name, int age){
		this.name = name;
		this.age = age;
		System.out.println("带有String,int的构造方法");
	}

	public Person(String name, int age, String address){
		this.name = name;
		this.age = age;
		this.address = address;
		System.out.println("带有String, int, String的构造方法");
	}


	//成员方法
	//没有返回值没有参数的方法
	public void method1(){
		System.out.println("没有返回值没有参数的方法");
	}
	//没有返回值,有参数的方法
	public void method2(String name){
		System.out.println("没有返回值,有参数的方法 name= "+ name);
	}
	//有返回值,没有参数
	public int method3(){
		System.out.println("有返回值,没有参数的方法");
		return 123;
	}
	//有返回值,有参数的方法
	public String method4(String name){
		System.out.println("有返回值,有参数的方法");
		return "哈哈" + name;
	}
	//私有方法
	private void method5(){
		System.out.println("私有方法");
	}


	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
	}
}
2.获取Class对象的三种方式
①通过Object类中的getObject()方法
	Person p = new Person();
	Class c = p.getClass();
②通过类名.class 获取到字节码文件对象(任意数据类型都具备一个class静态属性)
	Class c2 = Person.class;
③通过Class类中的方法(将类名作为字符串传递给Class类中的静态方法forName)
	Class c3 = Class.forName("com.neusoft.entity.Person");
3.反射的使用
(1)通过反射获取构造方法 Constructor
获取public修饰, 指定参数类型所对应的构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)
获取包含私有的指定参数类型所对应的构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
获取所有的public 修饰的构造方法
public Constructor<?>[] getConstructors()
获取包含私有的所有的构造方法
public Constructor<?>[] getDeclaredConstructors() 

  • 获取构造方法示例:
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
	//获取Class对象
	Class c = Class.forName("com.neusoft.Person");//包名.类名
	
	//获取所有的构造方法
	//Constructor[] cons = c.getConstructors();
	Constructor[] cons = c.getDeclaredConstructors();
	for (Constructor con : cons) {
		System.out.println(con);
	}
	
	System.out.println("------------------------");
	//获取一个构造方法
	//public Person() 
	Constructor con1 = c.getConstructor(null);
	System.out.println(con1);
	
	//public Person(String name)
	Constructor con2 = c.getConstructor(String.class);
	System.out.println(con2);
	
	//private Person(String name, int age)
	Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
	System.out.println(con3);
	
	//public Person(String name, int age, String address)
	Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
	System.out.println(con4);
}
  • 通过反射方式,获取构造方法,创建对象示例:
	Class c = Class.forName("com.neusoft.entity.Person");
	Constructor con = c.getConstructor(String.class, int.class, String.class);
	Object obj = con.newInstance("小明", 22, "哈尔滨");
  • 通过反射方式,获取私有构造方法,创建对象示例:
	//1,获取到Class对象
	Class c = Class.forName("com.neusoft.entityPerson");
	Constructor con = c.getDeclaredConstructor(String.class, int.class);
	//3,暴力反射 
	con.setAccessible(true);//取消 Java 语言访问检查
	//4,通过构造方法类中的功能,创建对象
	Object obj = con.newInstance("小明", 23);
	System.out.println(obj);
(2)通过反射获取对应的成员变量 Field
获取指定的public修饰的变量
public Field getField(String name) 
获取指定的包含私有的任意变量
public Field getDeclaredField(String name) 
获取所有public修饰的变量
public Field[] getFields()
获取包含私有的所有变量
public Field[] getDeclaredFields()

  • 获取成员变量示例:
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
		//获取Class对象
		Class c = Class.forName("com.neusoft.entity.Person");
		//获取成员变量
		//多个变量
		//Field[] fields = c.getFields();
		Field[] fields =  c.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field);
		}
		System.out.println("-----------------");
		//一个变量
		//public int age;
		Field ageField = c.getField("age");
		System.out.println(ageField);
		//private String address
		Field addressField = c.getDeclaredField("address");
		System.out.println(addressField);
	}

  • 通过反射,创建对象,获取指定的成员变量,进行赋值与获取值操作示例:
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
			InvocationTargetException, NoSuchFieldException {
	//1,获取Class对象
	Class c = Class.forName("com.neusoft.entity.Person");
	//2,获取构造方法
	//public Person(String name) 
	Constructor con = c.getConstructor(String.class);
	//3,通过构造方法,创建对象
	Object obj = con.newInstance("小明");
	//4,获取指定的成员变量
	//public String name;
	Field nameField = c.getField("name");
	//public int age;
	Field ageField = c.getField("age");
	//private String address;
	Field addressField = c.getDeclaredField("address");
	addressField.setAccessible(true); //取消 Java 语言访问检查
	//5,通过方法,给指定对象的指定成员变量赋值或者获取值
	System.out.println("name = "+ nameField.get(obj));
	System.out.println("age = "+ ageField.get(obj));
	System.out.println("address = "+ addressField.get(obj));
	//赋值
	ageField.set(obj, 23);
	addressField.set(obj, "凯利广场");
	System.out.println("------------------------");
	System.out.println("name = "+ nameField.get(obj));
	System.out.println("age = "+ ageField.get(obj));
	System.out.println("address = "+ addressField.get(obj));
}
(3)通过反射获取到对应的方法 Method
获取public修饰的方法
public Method getMethod(String name, Class<?>... parameterTypes)
  获取包含私有的任意方法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
获取本类与父类中所有public 修饰的方法
public Method[] getMethods()
获取本类中包含私有的所有的方法
public Method[] getDeclaredMethods() 

  • 获取成员方法示例:
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
	//获取Class对象
	Class c = Class.forName("com.neusoft.entity.Person");
	//获取多个方法
	//Method[] methods = c.getMethods();
	Method[] methods = c.getDeclaredMethods();
	for (Method method : methods) {
		System.out.println(method);
	}
	System.out.println("-----------------------");
	//获取一个方法:
	//public void method1()
	Method method = c.getMethod("method1", null);
	System.out.println(method);
	//public String method4(String name){
	method = c.getMethod("method4", String.class);
	System.out.println(method);
	//私有方法
	//private void method5()
	method = c.getDeclaredMethod("method5", null);
	System.out.println(method);
}

  • 通过反射,创建对象,调用指定的方法示例:
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
        InvocationTargetException {
    //1, 获取Class对象
    Class c = Class.forName("com.neusoft.entity.Person");
    //2,获取构造方法
    //public Person(String name, int age, String address){
    Constructor con = c.getConstructor(String.class, int.class, String.class);
    //3,通过构造方法,创建对象
    Object obj = con.newInstance("小明", 23, "哈尔滨");
    //4,获取指定的方法
    //public void method1()  没有返回值没有参数的方法
    //Method m1 = c.getMethod("method1", null);
    //public String method4(String name)
    Method m4 = c.getMethod("method4", String.class);
    //5,执行找到的方法
    //m1.invoke(obj, null);
    Object result = m4.invoke(obj, "itcast");
    System.out.println("result = " + result);
}
  • 通过反射,创建对象,调用指定的private方法示例:
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
        InvocationTargetException {
    //1, 获取Class对象
    Class c = Class.forName("cn.itcast_01_Reflect.Person");
    //2,获取构造方法
    //public Person(String name, int age, String address){
    Constructor con = c.getConstructor(String.class, int.class, String.class);
    //3,通过构造方法,创建对象
    Object obj = con.newInstance("小明", 23, "哈尔滨");
    //4,获取指定的方法
    //private void method5(){
    Method m5 = c.getDeclaredMethod("method5", null);
    //5,开启暴力访问
    m5.setAccessible(true);
    //6,执行找到的方法
    m5.invoke(obj, null);
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值