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创建对象的过程。

Java反射有什么优点

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
    }
}

运行结果：
Java反射有什么优点

通过上述比较三个对象的结果可以得出一个结论：同一个字节码文件(*.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修饰的构造函数Constructor getConstructor(类... 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);
    }
}

运行结果：

Java反射有什么优点

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);
    }
}

运行结果：

Java反射有什么优点

注意：如果没有忽略访问修饰符直接访问会抛出如下所示的异常

Java反射有什么优点

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()
 *    Constructor 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);
    }
}

运行结果：

Java反射有什么优点

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修饰的）
        }
    }
}

运行结果：

Java反射有什么优点

我们可以看出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);}}

运行结果：
Java反射有什么优点

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

Java反射有什么优点

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);
    }
}

运行结果:

Java反射有什么优点

6.7 修改配置文件，再次运行

className = com.czxy.mybatis_plus.test.Student 
methodName = study

运行结果:

Java反射有什么优点

感谢各位的阅读，以上就是“Java反射有什么优点”的内容了，经过本文的学习后，相信大家对Java反射有什么优点这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！

文章名称：Java反射有什么优点
文章转载：http://hbruida.cn/article/gcpphp.html

Java反射有什么优点

在谈反射之前，先思考一个问题，java中如何创建一个对象，有哪几种方式?

1、反射概述

1.1什么是反射

1.2、反射能干什么

1.3 反射的优点

1.4 获取Class对象的三种方式

2、Class对象的功能

2.1 获取功能

2.2 Field：成员变量

2.3 测试的实体类

2.4 测试getFields和getField(String name)方法

2.5 测试 getDeclaredFields 和 getDeclaredField(String name)方法

3、 Constructor:构造方法

3.1修改测试的实体类

3.2 测试获取构造函数的方法

4、 Method：方法对象

4.1 执行方法：Object invoke(Object obj, Object… args)

4.2 测试获取成员方法的方法

5、获取全类名

5.1 getName()方法获取的类名是全类名（带有路径）

6、反射机制的应用案例

6.1 需求

6.2 实现

6.3 步骤

6.4 代码实现 需要的实体类

6.5 编写配置文件

6.6 实现框架

6.7 修改配置文件，再次运行

其他资讯

6.4 代码实现需要的实体类