反射

最新推荐文章于 2024-08-30 18:40:43 发布

愚笨难解

最新推荐文章于 2024-08-30 18:40:43 发布

阅读量124

点赞数

分类专栏： java基础文章标签： java 反射

本文链接：https://blog.csdn.net/suo_jia_hao/article/details/110991207

版权

java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

反射概念:
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；
反射就是把java类中的各种成分映射成一个个的Java对象
好处:
1.可以在程序运行过程中,操作这些对象
2.可以解耦,提高程序的可扩展性

获得class的三种方法
(全类名 = 包名.类名)
1.class.forName(“全类名”),将字节码文件加载进内存,返回class对象
多用于配置文件,将类名定义在配置文件中.读取文件,加载类
2.类名.class,通过类名属性class获取
多用于参数的传递
3.对象.getClass();getClass()方法在Object中定义着
多用于对象的获取字节码的方式

**结论:**同一个字节码(*.class)在一次程序运行过程中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个

类加载器图解
在这里插入图片描述

*Class对象的功能
获取功能:
1.获取成员变量
*Field[] getFields() //获取所有public修饰的成员变量
*Field getField(String name)//获取指定名称的public修饰的成员变量

*Field[] getDeclaredFields()//获取所有的成员变量,不考虑修饰符
*Field getDeclaredField(String name)//获取所有指定名称的成员变量
2.获取构造方法
*Constructor<?>[] getConstructors()
*Constructor getConstructor(类<?>…parameterTypes)

*Constructor getDeclaredConstructor(类<?>…parameterTypes)
*Constructor<?>[] getDeclaredConstructor()
3.获取成员方法
*Method[] getMethods()
*Method getMethod(String name,类<?>… parameterTypes)

*Method[] getDeclaredMethods()
*Method getDeclaredMethod(String name,类<?>… parameterTypes)
4.获取类名
*String getName()

*Field:成员变量
*操作:
1.设置值
*set(Object obj,Object value)
2.获取值
*get(Object obj)
3.忽略访问权限修饰符的安全检查(暴力反射)
*setAccessible(true)

*constructor:构造方法
*操作:
1.创建对象
*newInstance([String,int…])
*如果使用空参数构造方法创建对象,操作可以简化
*Method:方法对象
*执行方法:

Object.invoke(Object obj,Object…args)
*获取指定方法名称
*String getName()

*案例:
需求:写一个”框架”,在不改变该类的任何代码的前提下,可以帮我们创建一个任意类的对象,并且执行其中的任意方法

*实现:
1.配置文件
2.反射
*步骤:
1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2.在程序中加载读取配置文件
3.使用反射技术来加载类文件进内存
4.执行对象
5.执行方法

被反射的Person类和Student类
(student类只有一个sleep(){print(“sleep…”)}方法,忽略)
package domain;
public class Person {
private String name;
private int age;

public String a = "值a";
protected String b = "值b";
String c = "值c";
private String d = "值d";

public static void main(String[] args) {
	Person a = new Person();
	a.toString();}
public Person() {
	}
public Person(String name, int age) {
	super();
	this.name = name;
	this.age = age;}
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 + ", a=" + a + ", b=" + b + ", c=" + c + ", d=" + d+ "]";}
public void eat() {
	System.out.println("eat...");
}

}

一.获取class反射的三种方式
package reflect;
import domain.Person;
/**本题反射对象是domain包下的Person.class字节码文件

获取class的三种方式
1.class.forName(“全类名”),将字节码文件加载进内存,返回class对象 (全类名 = 报名.类名)

 多用于配置文件,将类名定义在配置文件中.读取文件,加载类

2.类名.class,通过类名属性class获取
```
 多用于参数的传递
```

*3.对象.getClass();getClass()方法在Object中定义着

 多用于对象的获取字节码的方式

*/
public class ReflectDemo1{
public static void main(String[] args) throws Exception {
//1.Class.forName(“全类名”)//多用于配置文件,将类名定义在配置文件中.读取文件,加载类
Class cls1 = Class.forName(“domain.Person”);
System.out.println(cls1);

//2.类名.class//多用于参数的传递
Class cls2 = Person.class;
System.out.println(cls2);

//3.对象.getClass()//多用于对象的获取字节码的方式
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3);

//这三个显示的结果是一样的,同样,在内存中的地址也是一样的
//同一个字节码(*.class)在一次程序运行过程中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true
}

}

获取成员变量
package reflect;
import com.sun.jdi.Field;
import domain.Person;
public class Reflect获取成员变量 {
public static void main(String[] args) throws Exception{

	//0.获取Person的Class对象
	Class personClass = Person.class;
	/*1.获取成员变量
	*Field[] getFields()//获取所有public修饰的成员变量
	*Field getField(String name)//获取指定名称的public修饰的成员变量
	*Field[] getDeclaredFields()//获取所有的成员变量,不考虑修饰符
	*Field getDeclaredField(String name)//获取指定名称的所有的成员变量,不考虑修饰符*/
	//1.Field[] getFields() //获取所有public修饰的成员变量//数组存放
	java.lang.reflect.Field[] fields = personClass.getFields();
	for(java.lang.reflect.Field field :fields) {
		System.out.println(field);
	}
	System.out.println("---------------------------------------------------");
	//2.Field getField(String name)//获取指定名称的public修饰的成员变量
	java.lang.reflect.Field bbb = personClass.getField("a");
	//获取成员变量a的值
	Person p = new Person();
	Object values = bbb.get(p);
	System.out.println("a = "+values);
	//设置成员变量a的值
	bbb.set(p, "张三");
	System.out.println(p);//p是Person的实例对象,前面有toString方法,直接调用p相当于调用了p的toString方法
	
System.out.println("=======================================================");
	
	//1.Field[] getDeclaredFields()//获取所有的成员变量,不考虑修饰符//数组存放
	java.lang.reflect.Field[] declarefields = personClass.getDeclaredFields();
	for(java.lang.reflect.Field field :declarefields) {
		System.out.println(field);
	}
	System.out.println("---------------------------------------------------");
	//查看是否可以对private的值进行查找修改
	java.lang.reflect.Field ggg = personClass.getDeclaredField("d");
	ggg.setAccessible(true);//忽略访问权限的安全检查//暴力反射,将所有类型的变量都反射出来//如果不加这句,私有的将不会被打印出来
	Object values2 = ggg.get(p);
	System.out.println("d = "+values2);
	//2.Field getDeclaredField(String name)//获取指定名称的所有的成员变量,不考虑修饰符
	java.lang.reflect.Field aaa = personClass.getDeclaredField("c");
	aaa.setAccessible(true);
	//获取成员变量c的值
	Object valuse3 = aaa.get(p);
	System.out.println("包含字符c的成员变量为:"+valuse3);}}

获取构造方法
package reflect;
import java.lang.reflect.Constructor;
import com.sun.jdi.Field;
import domain.Person;
public class Reflect获取构造方法 {

public static void main(String[] args) throws Exception{
	
	//0.获取Person的Class对象
	Class personClass = Person.class;
	/*
	*Constructor<?>[] getConstructors()  
	*Constructor<T> getConstructor(类<?>...parameterTypes) //获取固定参数类型的构造方法

	 *Constructor<T> getDeclaredConstructor(类<?>...parameterTypes)
	 *Constructor<?>[] getDeclaredConstructor()
	*/
	//1.获取所有的构造方法
	
	//2.获取固定参数类型的构造方法
	Constructor con = personClass.getConstructor(String.class,int.class);//通过传参的类型来获取不同的构造方法
	System.out.println(con);
	//创建对象
	Object per = con.newInstance("张三",23);//创建对象时
	System.out.println(per);//toString 方法
	
	
}

}

获取成员方法
package reflect;
import com.sun.jdi.Field;
import com.sun.jdi.Method;
import domain.Person;
public class Reflect获取成员方法 {
public static void main(String[] args) throws Exception{
//0.获取Person的Class对象
Class personClass = Person.class;
/*
获取成员方法
*Method[] getMethods()获取所有public修饰的成员方法
*Method getMethod(String name,类<?>… parameterTypes)获取指定名称的成员方法

	 	*Method[] getDeclaredMethods()
	 	*Method getDeclaredMethod(String name,类<?>... parameterTypes)*/
	//1.获取指定名称的成员方法
	System.out.println("----------获取指定名称的成员方法-----");
	java.lang.reflect.Method method = personClass.getMethod("eat");
	Person p = new Person();
	//执行方法
	method.invoke(p);
	//获取方法名称
	String name = method.getName();
	System.out.println("获取方法名称"+name);
	System.out.println("---获取所有public修饰的成员方法----");
	//2.获取所有public修饰的成员方法
	java.lang.reflect.Method[] methodarr = personClass.getMethods();
	for(java.lang.reflect.Method me:methodarr) {
		System.out.println(me);
	}
	System.out.println("----------------------获取类名----------------------");
	//获取类名
	String className = personClass.getName();
	System.out.println(className);	}

}

*案例:
需求:写一个”框架”,在不改变该类的任何代码的前提下,可以帮我们创建一个任意类的对象,并且执行其中的任意方法

*实现:
1.配置文件
2.反射
*步骤:
6.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
7.在程序中加载读取配置文件
8.使用反射技术来加载类文件进内存
9.执行对象
10.执行方法
package reflect;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import com.sun.jdi.Method;

/**框架类的内部实现原理

1.先在src内部创建一个文件pro.properties
2.在该文件写入将要反射的类名,方法名等
*3.配置文件(下面的代码)
*4.以后想要反射其他类,只需将pro.properties中的类名和方法名更改为替换的即可
*className = domain.Person 替换 className = domain.Student
*methodName = eat 替换 methodName = sleep
/
public class ReflectTest {
@SuppressWarnings(“deprecation”)
public static void main(String[] args) throws Exception {
//可以创建任意类的对象,可以执行任意方法
/
*前提:不能改变该类的任何代码,可以创建任意类的对象,可以执行任意方法
*Person p = new Person();//直接调用可能会改变源代码,所以这里只能用反射
*p.eat();
*/
//1.加载配置文件(通过文件反射类对象)
//1.1创建Properties对象(文件)
Properties pro = new Properties();
//1.2加载配置文件,转换为一个集合
//1.2.1获取class目录下的配置文件
ClassLoader classLoader = ReflectTest.class.getClassLoader();//得到文件路径
InputStream is = classLoader.getResourceAsStream(“pro.properties”);//获取传入的文件的字节流
pro.load(is);
```
 //2.获取配置文件中定义的数据
 String className = pro.getProperty("className");
 String methodName = pro.getProperty("methodName");
 
 
 //3.加载该类进内存
 Class cls = Class.forName(className);
 //4.创建对象
 Object obj = cls.newInstance();
 //5.获取方法对象
 java.lang.reflect.Method method = cls.getMethod(methodName);
 //6.执行方法
 method.invoke(obj);
```
}
}

愚笨难解

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
反射

*反射概念:JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；反射就是把java类中的各种成分映射成一个个的Java对象好处:1.可以在程序运行过程中,操作这些对象2.可以解耦,提高程序的可扩展性获得class的三种方法(全类名 = 包名.类名)1.class.forName(“全类名”),将字节码文件加载进内存,返回class对象多用于配置文件,将类名定义在配置文件中.读取文件,加载类2.类名.class,
复制链接

扫一扫

专栏目录