【Java】用实例理解反射（一）

最新推荐文章于 2024-09-12 23:58:52 发布

Thinlk

最新推荐文章于 2024-09-12 23:58:52 发布

阅读量186

点赞数

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

本文链接：https://blog.csdn.net/sermory/article/details/106148275

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Java的反射机制，包括反射的概念、Class类的使用、获取构造方法、成员变量和方法的方式。通过反射，可以动态访问和操作类的属性和方法，实现代码的灵活性。文章通过实例演示了如何获取并使用Constructor、Field和Method对象，展示了反射在Java编程中的应用。

摘要由CSDN通过智能技术生成

一、反射概念

在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象方法的功能称为Java语言的反射机制。
通过Java反射机制，可以在程序中访问已经装载到JVM中的Java对象的描述，实现访问、检测和修改描述Java对象本身信息的功能。
类也是对象，它是java.lang.Class类的实例对象；Java中的反射主要通过Class类提供的方法实现。

二、Class类

Class类的实例表示正在运行的Java应用程序中的类和接口，它没有公共构造方法，要创建Class类的对象，可以有3种方法，

使用类的class属性，代码如下：

Class c = Demo.class;

使用Class类的forName()方法，代码如下

try {
    Class c = Class.forName("test.Demo");
} catch (ClassNotFoundException e1) {
    e1.printStackTrace();
}

注意：使用Class类的forName方法创建Class对象时，需要捕获ClassNotFoundException异常。

使用Object对象的getClass()方法，代码如下：

Demo demo = new Demo ();
Class c = demo.getClass();

注意：以上3种方法都可以创建Class类的对象，但它们创建的反射对象是完全相同的，也就是：一个类只能有一个反射对象，例如，使用以上3种方法分别创建同一个类的反射对象，并分别输出它们的哈希码值，代码如下

class Demo {
} // 定义一个类，用于测试，无实际意义
public class Test {
    public static void main(String[] args) {
        Class a = Demo.class; // 使用第1种方法创建Class对象
        System.out.println("第1个反射对象的哈希码："+a.hashCode()); // 输出对象的哈希码
        try {
            Class b = Class.forName("Demo"); // 使用第2种方法创建Class对象
            System.out.println("第2个反射对象的哈希码："+b.hashCode()); // 输出对象的哈希码
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
        Demo demo = new Demo(); // 创建Demo对象
        Class c = demo.getClass(); // 使用第3种方法创建Class对象
        System.out.println("第3个反射对象的哈希码："+c.hashCode()); // 输出对象的哈希码
        //方式四，使用类的加载器 ClassLoader (了解即可)
        Classloader classLoader = ReflectionTest.class.getClassLoader();
        Class d = classLoader.loadClass("Demo")
        System.out.println("第4个反射对象的哈希码："+c.hashCode()); 
    }
}

这3个对象的哈希码是完全相同的。
一个类只能有一个反射对象

2.1 通过反射可访问的主要描述信息

组成部分	访问方法	返回值类型	说明
包路径	getPackage()	Package对象	获得该类的存放路径
类名称	getName()	String对象	获得该类的名称
继承类	getSuperclass()	Class对象	获得该类集成的类
实现接口	getInterfaces()	Class型数组	获得该类实现的所有接口
构造方法	getConstructors()	Constructor型数组	获得所有权限为public的构造方法
构造方法	getConstructor(Class<?>…parameterTypes)	Constructor对象	获得权限为public的指定构造方法
构造方法	getDeclaredConstructors()	Constructor型数组	获得所有构造方法，按声明顺序返回
构造方法	getDeclaredConstructor(Class<?>… parameterTypes)	Constructor对象	获得指定构造方法
方法	getMethods()	Method型数组	获得所有权限为public的方法
方法	getMethod(String name, Class<?>… parameterTypes)	Method对象	获得权限为public的指定方法
方法	getDeclaredMethods()	Method型数组	获得所有方法，按声明顺序返回
方法	getDeclaredMethod(String name, Class<?>… parameterTypes)	Method对象	获得指定方法
成员变量	getFields()	Field型数组	获得所有权限为public的成员变量
成员变量	getField(String name)	Field对象	获得权限为public的指定成员变量
成员变量	getField(String name)	Field型数组	获得所有成员变量，按声明顺序返回
成员变量	getDeclaredField(String name)	Field对象	获得指定成员变量
内部类	getClasses()	Class型数组	获得所有权限为public的内部类
内部类	getDeclaredClasses()	Class型数组	获得所有内部类
内部类的声明类	getDeclaringClass()	Class对象	如果该类为内部类，则返回它的成员类，否则返回null

说明：在通过方法getFields()和getMethods()依次获得权限为public的成员变量和方法时，将包含从超类中继承到的成员变量和方法；而通过方法getDeclaredFields()和getDeclaredMethods()只是获得在本类中定义的所有成员变量和方法。

三、获取构造方法

getConstructors()：返回一个包含某些Constructor对象的数组，这些对象反映此Class对象所表示的类的所有公共构造方法。
getConstructor(Class<?>…parameterTypes)：返回一个Constructor对象它反映此Class对象所表示的类的指定公共构造方法。
getDeclaredConstructors()：返回Constructor对象的一个数组，这些对象反映此Class对象表示的类声明的所有构造方法。
getDeclaredConstructor(Class<?>…parameterTypes)：返回一个Constructor对象，该对象反映此Class对象所表示的类或接口的指定构造方法。

如果是访问指定的构造方法，需要根据该构造方法的入口参数的类型来访问。例如，访问一个入口参数类型依次为String和int型的构造方法，通过下面两种方式均可实现：

objectClass.getDeclaredConstructor(String.class, int.class);
objectClass.getDeclaredConstructor(new Class[] {String.class, int.class});

3.1 Constructor类的常用方法

方法	说明
isVarArgs()	查看该构造方法是否允许带有可变数量的参数，如果允许则返回true，否则返回false
getParameterTypes()	按照声明顺序以Class数组的形式获得该构造方法的各个参数的类型
getExceptionTypes()	以Class数组的形式获得该构造方法可能抛出的异常类型
newInstance(Object…initargs)	通过该构造方法利用指定参数创建一个该类的对象，如果未设置参数则表示采用默认无参数的构造方法
setAccessible(boolean flag)	如果该构造方法的权限为private，默认为不允许通过反射利用newInstance(Object… initargs)方法创建对象。如果先执行该方法，并将入口参数设为true，则允许创建
getModifiers()	获得可以解析出该构造方法所采用修饰符的整数

通过java.lang.reflect.Modifier类可以解析出getModifiers()方法的返回值所表示的修饰符信息，在该类中提供了一系列用来解析的静态方法，既可以查看是否被指定的修饰符修饰，还可以以字符串的形式获得所有修饰符。

3.2 Modifier类中的常用解析方法

静态方法	说明
isPublic(int mod)	查看是否被public修饰符修饰，如果是则返回true，否则返回false
isProtected(int mod)	查看是否被protected修饰符修饰，如果是则返回true，否则返回false
isPrivate(int mod)	查看是否被private修饰符修饰，如果是则返回true，否则返回false
isStatic(int mod)	查看是否被static修饰符修饰，如果是则返回true，否则返回false
isFinal(int mod)	查看是否被final修饰符修饰，如果是则返回true，否则返回false
toString(int mod)	以字符串的形式返回所有修饰符

例如，判断对象constructor所代表的构造方法是否被private修饰，以及以字符串形式获得该构造方法的所有修饰符的代码如下：

int modifiers = constructor.getModifiers();
boolean isEmbellishByPrivate = Modifier.isPrivate(modifiers);
String embellishment = Modifier.toString(modifiers);

3.3 获取构造方法

首先创建一个GetConstructorTest类，在该类中声明一个String型成员变量和3个int型成员变量，并提供3个构造方法。具体代码如下：

public class GetConstructorTest {
      String s; // 定义一个字符串变量
      int i, i2, i3; // 定义3个int变量
      
      private GetConstructorTest() { // 无参构造函数
      }
      
      // 有参构造函数，用来为字符串变量和int变量初始化值
      protected GetConstructorTest(String s, int i) {
           this.s = s;
           this.i = i;
      }

      public GetConstructorTest(String... strings) throws NumberFormatException {
           if (strings.length > 0) // 如果字符串长度大于0
                 i = Integer.valueOf(strings[0]); // 将字符串的第1个字符串赋值给变量i
           if (strings.length > 1)// 如果字符串长度大于1
                 i2 = Integer.valueOf(strings[1]);// 将字符串的第2个字符串赋值给变量i2
           if (strings.length > 2)// 如果字符串长度大于2
                 i3 = Integer.valueOf(strings[2]);// 将字符串的第3个字符串赋值给变量i3
      }

      public void print() {
           // 输出成员变量的值
           System.out.println("s=" + s);
           System.out.println("i=" + i);
           System.out.println("i2=" + i2);
           System.out.println("i3=" + i3);
      }
}

然后编写测试类GetConstructorMain，在该类中通过反射获取GetConstructorTest类中的所有构造方法，并将该构造方法是否允许带有可变数量的参数、入口参数类型和可能抛出的异常类型信息输出到控制台。具体代码如下：

package reflect;

import java.lang.reflect.Constructor;

public class GetConstructorMain {
    public static void main(String[] args) {
        GetConstructorTest example = new GetConstructorTest("10", "20", "30");
        Class<? extends GetConstructorTest> exampleC = example.getClass();

        // 获得所有构造方法
        Constructor[] declaredConstructors = exampleC.getDeclaredConstructors();
        for (int i = 0; i < declaredConstructors.length; i++) {// 遍历构造方法
              Constructor<?> constructor = declaredConstructors[i];
              System.out.println("查看是否允许带有可变数量的参数：" + constructor.isVarArgs());
              System.out.println("该构造方法的入口参数类型依次为：");
              Class[] parameterTypes = constructor.getParameterTypes();// 获取所有参数类型
              for (int j = 0; j < parameterTypes.length; j++) {
                   System.out.print(" "+parameterTypes[j].getSimpleName());
                   System.out.println();
              }
              System.out.println("该构造方法可能抛出的异常类型为：");
              // 获得所有可能抛出的异常信息类型
              Class[] exceptionTypes = constructor.getExceptionTypes();
              for (int j = 0; j < exceptionTypes.length; j++) {
                   System.out.println(exceptionTypes[j]);
              }
              GetConstructorTest example2 = null;
              while (example2 == null) {
                   try {// 如果该成员变量的访问权限为private，则抛出异常，即不允许访问
                         if (i == 2)// 通过执行默认没有参数的构造方法创建对象
                               example2 = (GetConstructorTest) constructor.newInstance();
                         else if (i == 1)
                               // 通过执行具有两个参数的构造方法创建对象
                               example2 = (GetConstructorTest) constructor.newInstance("7", 5);
                         else {// 通过执行具有可变数量参数的构造方法创建对象
                               Object[] parameters = new Object[] { new String[] { "100", "200", "300" } };
                               example2 = (GetConstructorTest) constructor.newInstance(parameters);
                         }
                   } catch (Exception e) {
                         System.out.println("在创建对象时抛出异常，下面执行setAccessible()方法");
                         constructor.setAccessible(true);// 设置为允许访问
                   }
              }
              if (example2 != null) {
                   example2.print();
                   System.out.println();
              }
        }
   }
}

返回结果1

四、获取成员变量

getFields()：返回一个包含某些Field对象的数组，这些对象反映此Class对象所表示的类或接口的所有可访问公共字段。
getField(String name)：返回一个Field对象，它反映此Class对象所表示的类或接口的指定公共成员字段。
getDeclaredFields()：返回Field对象的一个数组，这些对象反映此Class对象所表示的类或接口所声明的所有字段。
getDeclaredField(String name)：返回一个Field对象，该对象反映此Class对象所表示的类或接口的指定已声明字段。

如果是访问指定的成员变量，可以通过该成员变量的名称来访问。例如，访问一个名称为birthday的成员变量，访问方法如下：

object.getDeclaredField("birthday");

4.1 Field类的常用方法

方法	说明
getName()	获得该成员变量的名称
getType()	获得表示该成员变量类型的Class对象
get(Object obj)	获得指定对象obj中成员变量的值，返回值为Object型
set(Object obj, Object value)	将指定对象obj中成员变量的值设置为value
getInt(Object obj)	获得指定对象obj中类型为int的成员变量的值
setInt(Object obj, int i)	将指定对象obj中类型为int的成员变量的值设置为i
getFloat(Object obj)	获得指定对象obj中类型为float的成员变量的值
setFloat(Object obj, float f)	将指定对象obj中类型为float的成员变量的值设置为f
getBoolean(Object obj)	获得指定对象obj中类型为boolean的成员变量的值
setBoolean(Object obj, boolean z)	将指定对象obj中类型为boolean的成员变量的值设置为z
setAccessible(boolean flag)	此方法可以设置是否忽略权限限制直接访问private等私有权限的成员变量
getModifiers()	获得可以解析出该成员变量所采用修饰符的整数

4.2 获取成员变量

首先创建一个GetFieldTest类，在该类中依次声明一个int、float、boolean和String型的成员变量，并将它们设置为不同的访问权限。具体代码如下：

public class GetFieldTest {
      int i; // 定义int类型成员变量
      public float f; // 定义float类型成员变量
      protected boolean b; // 定义boolean类型成员变量
      private String s; // 定义私有的String类型成员变量

}

package reflect.field;

import java.lang.reflect.*;

public class GetFieldMain {
      public static void main(String[] args) {
           GetFieldTest example = new GetFieldTest();
           Class exampleC = example.getClass();
           // 获得所有成员变量
           Field[] declaredFields = exampleC.getDeclaredFields();
           for (int i = 0; i < declaredFields.length; i++) {
                 Field field = declaredFields[i]; // 遍历成员变量
                 // 获得成员变量名称
                 System.out.println("名称为：" + field.getName());
                 Class fieldType = field.getType(); // 获得成员变量类型
                 System.out.println("类型为：" + fieldType);
                 boolean isTurn = true;
                 while (isTurn) {
                      // 如果该成员变量的访问权限为private，则抛出异常，即不允许访问
                      try {
                            isTurn = false;
                            // 获得成员变量值
                            System.out.println("修改前的值为：" + field.get(example));
                            // 判断成员变量的类型是否为int型
                            if (fieldType.equals(int.class)) {
                                  System.out.println("利用方法setInt()修改成员变量的值");
                                  field.setInt(example, 168); // 为int型成员变量赋值
                                  // 判断成员变量的类型是否为float型
                            } else if (fieldType.equals(float.class)) {
                                  System.out.println("利用方法setFloat()修改成员变量的值");
                                  // 为float型成员变量赋值
                                  field.setFloat(example, 99.9F);
                                  // 判断成员变量的类型是否为boolean型
                            } else if (fieldType.equals(boolean.class)) {
                                  System.out.println("利用方法setBoolean()修改成员变量的值");
                                  // 为boolean型成员变量赋值
                                  field.setBoolean(example, true);
                            } else {
                                  System.out.println("利用方法set()修改成员变量的值");
                                  // 可以为各种类型的成员变量赋值
                                  field.set(example, "MWQ");
                            }
                            // 获得成员变量值
                            System.out.println("修改后的值为：" + field.get(example));
                      } catch (Exception e) {
                            System.out.println("在设置成员变量值时抛出异常，" + "下面执行setAccessible()方法！");
                            field.setAccessible(true); // 设置为允许访问
                            isTurn = true;
                      }
                 }
                 System.out.println();
           }
      }
}

执行结果2

五、获取方法

getMethods()：返回一个包含某些Method对象的数组，这些对象反映此Class对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共成员方法。
getMethod(String name,Class<?>…parameterTypes)：返回一个Method对象，它反映此Class对象所表示的类或接口的指定公共成员方法。
getDeclaredMethods()：返回Method对象的一个数组，这些对象反映此Class对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
getDeclaredMethod(String name,Class<?>…parameterTypes)：返回一个Method对象，该对象反映此Class对象所表示的类或接口的指定已声明方法。

如果是访问指定的方法，需要根据该方法的名称和入口参数的类型来访问。例如，访问一个名称为print、入口参数类型依次为String和int型的方法，通过下面两种方式均可实现：

objectClass.getDeclaredMethod("print", String.class, int.class);
objectClass.getDeclaredMethod("print", new Class[] {String.class, int.class });

5.1 Method类的常用方法

方法	说明
getName()	获得该方法的名称
getParameterTypes()	按照声明顺序以Class数组的形式获得该方法的各个参数的类型
getReturnType()	以Class对象的形式获得该方法的返回值的类型
etExceptionTypes()	以Class数组的形式获得该方法可能抛出的异常类型
invoke(Object obj, Object…args)	利用指定参数args执行指定对象obj中的该方法，返回值为Object型
isVarArgs()	查看该方法是否允许带有可变数量的参数，如果允许则返回true，否则返回false
getModifiers()	获得可以解析出该方法所采用修饰符的整数

5.2 获取成员方法

package reflect.method;

public class GetMehodTest {
    static void staticMethod() {// 定义静态方法，用于测试，无实际意义
        System.out.println("执行staticMethod()方法");
   }

   public int publicMethod(int i) {// 定义共有方法，用于测试，无实际意义
        System.out.println("执行publicMethod()方法");
        return i * 100;
   }

   protected int protectedMethod(String s, int i)// 定义保护方法，用于测试，无实际意义
              throws NumberFormatException {
        System.out.println("执行protectedMethod()方法");
        return Integer.valueOf(s) + i;
   }


   private String privateMethod(String... strings) {// 定义私有方法，用于测试，无实际意义
        System.out.println("执行privateMethod()方法");
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < strings.length; i++) {
              stringBuffer.append(strings[i]);
        }
        return stringBuffer.toString();
   }
}

package reflect.method;

import java.lang.reflect.Method;

public class GetMethodMain {

    public static void main(String[] args) {
         GetMehodTest example = new GetMehodTest();
         Class<? extends GetMehodTest> exampleC = example.getClass();
         // 获得所有方法
         Method[] declaredMethods = exampleC.getDeclaredMethods();
         for (int i = 0; i < declaredMethods.length; i++) {
               Method method = declaredMethods[i]; // 遍历方法
               System.out.println("名称为：" + method.getName()); // 获得方法名称
               System.out.println("是否允许带有可变数量的参数：" + method.isVarArgs());
               System.out.println("入口参数类型依次为：");

               // 获得所有参数类型
               Class[] parameterTypes = method.getParameterTypes();
               for (int j = 0; j < parameterTypes.length; j++) {
                    System.out.println(" " + parameterTypes[j].getSimpleName());
               }
               // 获得方法返回值类型
               System.out.println("返回值类型为：" + method.getReturnType());
               System.out.println("可能抛出的异常类型有：");
               // 获得方法可能抛出的所有异常类型
               Class[] exceptionTypes = method.getExceptionTypes();
               for (int j = 0; j < exceptionTypes.length; j++) {
                    System.out.println(" " + exceptionTypes[j]);
               }
               boolean isTurn = true;
               while (isTurn) {
                    // 如果该方法的访问权限为private，则抛出异常，即不允许访问
                    try {
                          isTurn = false;
                          if ("staticMethod".equals(method.getName()))
                                method.invoke(example); // 执行没有入口参数的方法
                          else if ("publicMethod".equals(method.getName()))
                                System.out.println("返回值为：" + method.invoke(example, 168)); // 执行方法
                          else if ("protectedMethod".equals(method.getName()))
                                System.out.println("返回值为：" + method.invoke(example, "7", 5)); // 执行方法
                          else if ("privateMethod".equals(method.getName())) {
                                Object[] parameters = new Object[] { new String[] { "M", "W", "Q" } }; // 定义二维数组
                                System.out.println("返回值为：" + method.invoke(example, parameters));
                          }

                    } catch (Exception e) {
                          System.out.println("在执行方法时抛出异常，" + "下面执行setAccessible()方法！");
                          method.setAccessible(true); // 设置为允许访问
                          isTurn = true;
                    }
               }
               System.out.println();
         }

    }

}