这篇文章主要讲解了“Java反射有什么优点”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java反射有什么优点”吧！
Java中创建对象大概有这几种方式：
1、使用new关键字：这是我们最常见的也是最简单的创建对象的方式
2、使用Clone的方法：无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面的对象的内容全部拷贝进去
3、使用反序列化：当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象
上边是Java中常见的创建对象的三种方式，其实除了上边的三种还有另外一种方式，就是接下来我们要讨论的 “反射”
在程序运行状态中，对于任意一个类或对象，都能够获取到这个类的所有属性和方法（包括私有属性和方法），这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来讲，通过反射，类对我们是完全透明的，想要获取任何东西都可以。
反射它把Java类中的各个部分，映射成一个个的Java对象，拿到这些对象后可以做一些事情。既然说反射是反射Java类中的各个组成部分，所以说我们得知道一个类中有哪儿些部分？
例如，一个类有：成员变量，方法，构造方法，等信息，利用反射技术咱们可以把这些组成部分映射成一个个对象。
一般来说反射是用来做框架的，或者说可以做一些抽象度比较高的底层代码，反射在日常的开发中用到的不多，但是我们还必须搞懂它，因为搞懂了反射以后，可以帮助咱们理解框架的一些原理。所以说有一句很经典的话：反射是框架设计的灵魂。
可以在程序运行过程中，操作这些对象；
可以解耦，提高程序的可扩展性。
在学习反射以前，我们先来了解一下Java代码在计算机中所经历的三个阶段：
Source源代码阶段：.java被编译成*.class字节码文件。
Class类对象阶段：.class字节码文件被类加载器加载进内存，并将其封装成Class对象（用于在内存中描述字节码文件），Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[]，将成员方法封装成数组Method[]。当然Class类内不止这三个，还封装了很多，我们常用的就这三个。
RunTime运行时阶段：使用new创建对象的过程。
【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对象都是同一个。
这里只写出一些常用的，具体可以参看jdk的帮助文档。
获取成员变量
Field[] getFields() //获取所有public修饰的成员变量Field getField(String name) //获取指定名称的public修饰的成员变量Field[] getDeclaredFields() //获取所有的成员变量，不考虑修饰符Field getDeclaredField(String name) //获取指定的成员变量，不考虑修饰符2. 获取构造方法
Constructor<?>[] getConstructors() //获取所有public修饰的构造函数Constructor<T> getConstructor(类<?>... parameterTypes) //获取指定的public修饰的构造函数Constructor<?>[] getDeclaredConstructors() //获取所有的构造函数，不考虑修饰符Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) //获取指定的构造函数，不考虑修饰符3. 获取成员方法
Method[] getMethods() //获取所有public修饰的成员方法Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法Method[] getDeclaredMethods() //获取所有的成员方法，不考虑修饰符Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法，不考虑修饰符4. 获取全类名
String getName()（1）设置值 set(Object obj, Object value)
（2）获取值 get(Object obj)
（3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Person {
public String a; //最大范围public
protected String b; //受保护类型
String c; //默认的访问权限
private String d; //私有类型
}/**
* 获取成员变量
* * 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);
}
}运行结果：
/**
* 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);
}
}运行结果：
注意：如果没有忽略访问修饰符直接访问会抛出如下所示的异常
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;
}
}/**
* 获取构造方法
* Constructor<?>[] getConstructors()
* Constructor<T> getConstructor(类<?>... 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);
}
}运行结果：
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);
}
}/**
* 获取成员方法
* * 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)方法进行暴力反射。
综上所述：在反射面前没有公有私有，都可以通过暴力反射解决。
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);}}运行结果：
写一个"框架"，在不改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中的任意方法。
（1）配置文件
（2）反射机制
（1）将需要创建的对象的全类名和需要执行的方法定义在配置文件中
（2）在程序中加载读取配置文件
（3）使用反射技术把类文件加载进内存
（4）创建对象
（5）执行方法
(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");}}className = com.czxy.mybatis_plus.test.Person
methodName = test
/**
* 前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
* 即：拒绝硬编码
*/
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);
}
}运行结果:
className = com.czxy.mybatis_plus.test.Student
methodName = study运行结果:
感谢各位的阅读，以上就是“Java反射有什么优点”的内容了，经过本文的学习后，相信大家对Java反射有什么优点这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！
亿速云「云服务器」，即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘，价格低至29元/月。点击查看>>
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
原文链接：https://my.oschina.net/u/4234912/blog/4525375
