Java反射有什么优点
这篇文章主要讲解了“Java反射有什么优点”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java反射有什么优点”吧!
武威网站建设公司创新互联,武威网站设计制作,有大型网站制作公司丰富经验。已为武威上千余家提供企业网站建设服务。企业网站搭建\外贸网站制作要多少钱,请找那个售后服务好的武威做网站的公司定做!
在谈反射之前,先思考一个问题,java中如何创建一个对象,有哪几种方式?
Java中创建对象大概有这几种方式:
1、使用new关键字:这是我们最常见的也是最简单的创建对象的方式
2、使用Clone的方法:无论何时我们调用一个对象的clone方法,JVM就会创建一个新的对象,将前面的对象的内容全部拷贝进去
3、使用反序列化:当我们序列化和反序列化一个对象,JVM会给我们创建一个单独的对象
上边是Java中常见的创建对象的三种方式,其实除了上边的三种还有另外一种方式,就是接下来我们要讨论的 “反射”
1、反射概述
1.1什么是反射
在程序运行状态中,对于任意一个类或对象,都能够获取到这个类的所有属性和方法(包括私有属性和方法),这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来讲,通过反射,类对我们是完全透明的,想要获取任何东西都可以。
反射它把Java类中的各个部分,映射成一个个的Java对象,拿到这些对象后可以做一些事情。既然说反射是反射Java类中的各个组成部分,所以说我们得知道一个类中有哪儿些部分?
例如,一个类有:成员变量,方法,构造方法,等信息,利用反射技术咱们可以把这些组成部分映射成一个个对象。
1.2、反射能干什么
一般来说反射是用来做框架的,或者说可以做一些抽象度比较高的底层代码,反射在日常的开发中用到的不多,但是我们还必须搞懂它,因为搞懂了反射以后,可以帮助咱们理解框架的一些原理。所以说有一句很经典的话:反射是框架设计的灵魂。
1.3 反射的优点
可以在程序运行过程中,操作这些对象;
可以解耦,提高程序的可扩展性。
在学习反射以前,我们先来了解一下Java代码在计算机中所经历的三个阶段:
Source源代码阶段:.java被编译成*.class字节码文件。
Class类对象阶段:.class字节码文件被类加载器加载进内存,并将其封装成Class对象(用于在内存中描述字节码文件),Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[],将成员方法封装成数组Method[]。当然Class类内不止这三个,还封装了很多,我们常用的就这三个。
RunTime运行时阶段:使用new创建对象的过程。
1.4 获取Class对象的三种方式
【Source源代码阶段】 Class.forName(“全类名”):将字节码文件加载进内存,返回Class对象;
多用于配置文件,将类名定义在配置文件中,通过读取配置文件加载类。【Class类对象阶段】 类名.class:通过类名的属性class获取;
多用于参数的传递【Runtime运行时阶段】对象.getClass():此方法是定义在Objec类中的方法,因此所有的类都会继承此方法。
多用于对象获取字节码的方式
//方法演示 public class getClass { public static void main(String[] args) throws Exception { //方式一:Class.forName("全类名"); Class class1 = Class.forName("com.czxy.mybatis_plus.test.Person"); //Person自定义实体类 System.out.println("class1 = " + class1); //方式二:类名.class Class class2 = Person.class; System.out.println("class2 = " + class2); //方式三:对象.getClass(); Person person = new Person(); Class class3 = person.getClass(); System.out.println("class3 = " + class3); //比较三个对象 System.out.println(class1 == class2); //true System.out.println(class1 == class3); //true } }
运行结果:
通过上述比较三个对象的结果可以得出一个结论:同一个字节码文件(*.class)在一次程序运行过程中,只会被加载一次,无论通过哪一种方式获取的Class对象都是同一个。
2、Class对象的功能
2.1 获取功能
这里只写出一些常用的,具体可以参看jdk的帮助文档。
获取成员变量
Field[] getFields() //获取所有public修饰的成员变量Field getField(String name) //获取指定名称的public修饰的成员变量Field[] getDeclaredFields() //获取所有的成员变量,不考虑修饰符Field getDeclaredField(String name) //获取指定的成员变量,不考虑修饰符
2. 获取构造方法
Constructor>[] getConstructors() //获取所有public修饰的构造函数ConstructorgetConstructor(类>... parameterTypes) //获取指定的public修饰的构造函数Constructor>[] getDeclaredConstructors() //获取所有的构造函数,不考虑修饰符Constructor getDeclaredConstructor(类>... parameterTypes) //获取指定的构造函数,不考虑修饰符
3. 获取成员方法
Method[] getMethods() //获取所有public修饰的成员方法Method getMethod(String name, 类>... parameterTypes) //获取指定名称的public修饰的成员方法Method[] getDeclaredMethods() //获取所有的成员方法,不考虑修饰符Method getDeclaredMethod(String name, 类>... parameterTypes) //获取指定名称的成员方法,不考虑修饰符
4. 获取全类名
String getName()
2.2 Field:成员变量
(1)设置值 set(Object obj, Object value)
(2)获取值 get(Object obj)
(3)忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射
2.3 测试的实体类
import lombok.Data; import lombok.ToString; @Data @ToString public class Person { public String a; //最大范围public protected String b; //受保护类型 String c; //默认的访问权限 private String d; //私有类型 }
2.4 测试getFields和getField(String name)方法
/** * 获取成员变量 * * Field[] getFields() * * Field getField(String name) * @throws Exception */ public class reflectDemo{ public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //1、Field[] getFields()获取所有public修饰的成员变量 Field[] fields = personClass.getFields(); for(Field field : fields){ System.out.println(field); } System.out.println("============================="); //2.Field getField(String name) 获取指定名称的public修饰的成员变量 Field a = personClass.getField("a"); //获取成员变量a的值 [也只能获取公有的,获取私有的或者不存在的字符会抛出异常] Person p = new Person(); Object value = a.get(p); System.out.println("value = " + value);//因为在Person类中a没有赋值,所以为null //设置成员变量a的属性值 a.set(p,"李四"); System.out.println(p); } }
运行结果:
2.5 测试 getDeclaredFields 和 getDeclaredField(String name)方法
/** * Field[] getDeclaredFields() * Field getDeclaredField(String name) * @throws Exception */ public class reflectDemo1 { public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //Field[] getDeclaredFields():获取所有的成员变量,不考虑修饰符 Field[] declaredFields = personClass.getDeclaredFields(); for(Field filed : declaredFields){ System.out.println(filed); } System.out.println("==================================="); //Field getDeclaredField(String name) //获取指定的成员变量,不考虑修饰符 Field d = personClass.getDeclaredField("d"); //private String d; Person p = new Person(); //Object value1 = d.get(p); //如果直接获取会抛出异常,因为对于私有变量虽然能会获取到,但不能直接set和get,必须忽略访问权限修饰符的安全检查后才可以 //System.out.println("value1 = " + value1); //忽略访问权限修饰符的安全检查,又称为暴力反射 d.setAccessible(true); Object value2 = d.get(p); System.out.println("value2 = " + value2); } }
运行结果:
注意:如果没有忽略访问修饰符直接访问会抛出如下所示的异常
3、 Constructor:构造方法
3.1修改测试的实体类
import lombok.Data; import lombok.ToString; @Data @ToString public class Person { private String name; private Integer age; //无参构造函数 public Person() { } //单个参数的构造函数,且为私有构造方法 private Person(String name){ } //有参构造函数 public Person(String name, Integer age) { this.name = name; this.age = age; } }
3.2 测试获取构造函数的方法
/** * 获取构造方法 * Constructor>[] getConstructors() * ConstructorgetConstructor(类>... parameterTypes) */ public class reflectDemo2{ public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //Constructor>[] getConstructors() //获取所有public修饰的构造函数 Constructor[] constructors = personClass.getConstructors(); for(Constructor constructor : constructors){ System.out.println(constructor); } System.out.println("=========================================="); //获取无参构造函数 注意:Person类中必须要有无参的构造函数,不然抛出异常 Constructor constructor1 = personClass.getConstructor(); System.out.println("constructor1 = " + constructor1); //使用获取到的无参构造函数创建对象 Object person1 = constructor1.newInstance(); System.out.println("person1 = " + person1); System.out.println("=========================================="); //获取有参的构造函数 //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致,且参数类型为字节码文件类型 Constructor constructor2 = personClass.getConstructor(String.class,Integer.class); System.out.println("constructor2 = " + constructor2); //使用获取到的有参构造函数创建对象 Object person2 = constructor2.newInstance("zhangsan", 22); //获取的是有参的构造方法,就必须要指定参数 System.out.println(person2); System.out.println("========================================="); //对于一般的无参构造函数,我们都不会先获取无参构造器之后在进行初始化,而是直接调用Class类内的newInstance()方法 Object person3 = personClass.newInstance(); System.out.println("person3 = " + person3); } }
运行结果:
4、 Method:方法对象
4.1 执行方法:Object invoke(Object obj, Object… args)
import lombok.Data; import lombok.ToString; @Data @ToString public class Person { private String name; private Integer age; //无参构造函数 public Person() { } //有参构造函数 public Person(String name, Integer age) { this.name = name; this.age = age; } //无参方法 public void test(){ System.out.println("test..."); } //重载有参方法 public void test(String food){ System.out.println("test..."+food); } }
4.2 测试获取成员方法的方法
/** * 获取成员方法 * * Method[] getMethods() * * Method getMethod(String name, 类>... parameterTypes) */ public class reflectDemo3 { public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //获取指定名称的方法 Method method1 = personClass.getMethod("test"); //执行方法 Person person = new Person(); Object rtValue = method1.invoke(person);//如果方法有返回值类型可以获取到,没有就为null //因为eat方法没有返回值,故输出null System.out.println("rtValue = " + rtValue); System.out.println("--------------------------------------------"); //获取有参的函数,有两个参数:第一个参数为方法名,第二个参数是获取方法的参数类型的字节码文件 Method method2 = personClass.getMethod("test", String.class); //执行方法 method2.invoke(person,"嗨"); System.out.println("============================================"); //获取方法列表 Method[] methods = personClass.getMethods(); for(Method method : methods){ //注意:获取到的方法不仅仅是Person类内自己的方法 System.out.println(method); //继承Object中的方法也会被获取到(当然前提是public修饰的) } } }
运行结果 :
我们可以看出Person内的public方法都被打印出来了,此外Object中的public方法也都被打印出来了。
同之前的叙述一样,带有Declared关键字的方法这两个方法,可以获取到任意修饰符的方法。同样也提供了setAccessible(true)方法进行暴力反射。
综上所述:在反射面前没有公有私有,都可以通过暴力反射解决。
5、获取全类名
5.1 getName()方法获取的类名是全类名(带有路径)
public class getNameDemo {public static void main(String[] args) throws Exception {//获取Person的Class对象Class personClass = Person.class;//获取全类名String className = personClass.getName();System.out.println(className);}}
运行结果:
6、反射机制的应用案例
6.1 需求
写一个"框架",在不改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中的任意方法。
6.2 实现
(1)配置文件
(2)反射机制
6.3 步骤
(1)将需要创建的对象的全类名和需要执行的方法定义在配置文件中
(2)在程序中加载读取配置文件
(3)使用反射技术把类文件加载进内存
(4)创建对象
(5)执行方法
6.4 代码实现 需要的实体类
(1)Person类
public class Person { //无参方法 public void test(){ System.out.println("test..."); } }
(2)Student类
public class Student {//无参方法public void study(){System.out.println("I'm Student");}}
6.5 编写配置文件
className = com.czxy.mybatis_plus.test.Person methodName = test
6.6 实现框架
/** * 前提:不能改变该类的任何代码。可以创建任意类的对象,可以执行任意方法 * 即:拒绝硬编码 */ public class ReflectTest { public static void main(String[] args) throws Exception { //1.加载配置文件 //1.1创建Properties对象 Properties pro = new Properties(); //1.2加载配置文件 //1.2.1获取class目录下的配置文件(使用类加载器) ClassLoader classLoader = ReflectTest.class.getClassLoader(); InputStream inputStream = classLoader.getResourceAsStream("pro.properties"); pro.load(inputStream); //2.获取配置文件中定义的数据 String className = pro.getProperty("className"); String methodName = pro.getProperty("methodName"); //3.加载该类进内存 Class cls = Class.forName(className); //4.创建对象 Object obj = cls.newInstance(); //5.获取方法对象 Method method = cls.getMethod(methodName); //6.执行方法 method.invoke(obj); } }
运行结果:
6.7 修改配置文件,再次运行
className = com.czxy.mybatis_plus.test.Student methodName = study
运行结果:
感谢各位的阅读,以上就是“Java反射有什么优点”的内容了,经过本文的学习后,相信大家对Java反射有什么优点这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是创新互联,小编将为大家推送更多相关知识点的文章,欢迎关注!
网站栏目:Java反射有什么优点
网址分享:http://azwzsj.com/article/gcpphp.html