【Java】【重要特性】详解反射

举报
huahua.Dr 发表于 2022/09/27 00:31:12 2022/09/27
【摘要】 一、什么是反射反射就是Reflection，Java的反射是指程序在运行期可以拿到一个对象的所有信息。二、为什么需要反射正常情况下，如果我们要调用一个对象的方法，或者访问一个对象的字段，通常会传入对象实例；但是如果我们想不传对象实例，也去调用对象的方法或者字段该怎么办呢？这种场景一般出现在运行态，想动态获取对象的方法或者字段。解决办法就是通过反射，反射是为了解决在运行期，对某个实例一无所知的...

一、什么是反射

反射就是Reflection，Java的反射是指程序在运行期可以拿到一个对象的所有信息。

二、为什么需要反射

正常情况下，如果我们要调用一个对象的方法，或者访问一个对象的字段，通常会传入对象实例；但是如果我们想不传对象实例，也去调用对象的方法或者字段该怎么办呢？这种场景一般出现在运行态，想动态获取对象的方法或者字段。

解决办法就是通过反射，反射是为了解决在运行期，对某个实例一无所知的情况下，如何调用其方法，访问其属性。

三、如何使用反射

（1）使用反射之前得先弄清楚一个基础类：Class类

在java 种，数据类型有基本类型和引用类型，基本类型就是那八大基本类型（byte-8,short-16,int-32,long-64,float-32,double-64,boolean-true/false,char-16）,引用类型就是我们经常使用的一个个类实例，那么这些类实例就是我们编译好的一个个.class文件实例化出来的，为什么叫.class文件呢，应为这些一个个.class文件的类型就是class（包括jdk自带的class文件，自己定义class文件，也包括interface）,他们的类型都是class,其对应有一个Class类（jdk自带的），Class是Java中的java.lang.Class类。

  • Class类用于记录Java中每个类的类型信息，并且jvm在类加载时会为每个类生成一个Class的Class对象在Java堆中，每个类的实例都要通过这个Class对象来进行实例化。
  • Class类也是类的一种，只是名字和class关键字高度相似。Java是大小写敏感的语言。
  • Class类的对象内容是你创建的类的类型信息，比如你创建一个xx类(使用class声明的类)，那么，Java会生成一个内容是xx的Class类的对象。也就是说JVM在第一次读取到某种class类型的类时，将其加载进内存。每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。
  • Class类的对象不能像普通类一样，以 new 的方式创建，它的对象只能由JVM创建，因为这个类没有public构造函数，如果我们查看JDK源码，可以发现Class类的构造方法是private，只有JVM能创建Class实例，我们自己的Java程序是无法创建Class实例的。所以，JVM持有的每个Class实例都指向一个数据类型（class或interface）
    /*

     * Private constructor. Only the Java Virtual Machine creates Class objects.

     * This constructor is not used and prevents the default constructor being

     * generated.

     */

     //私有构造方法，只能由jvm进行实例化

    private Class(ClassLoader loader) {

        // Initialize final field for classLoader.  The initialization value of non-null

        // prevents future JIT optimizations from assuming this final field is null.

        classLoader = loader;

    }

Class类的作用是运行时提供或获得某个对象的类型信息，和C++中的typeid()函数类似。这些信息也可用于反射。

那么获取Class对象的方法有哪些（在运行时）：

  • 我们所有类都继承了Object类，Object类里面有Native方法：getClass()，通过实例对象调用getClass()方法：

String s = "Hello";

Class cls = s.getClass();

  • 所有的数据类型（包括基本类型和引用类型）都有一个静态的class属性，可以直接调用：

Class cls = String.class;

  • 通过Class类的静态方法Class.forName(String className),通过传入完全限类名称获取该类的Class对象：

Class cls = Class.forName("java.lang.String");

因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例。

注意一下Class实例比较和instanceof的差别：

Integer n = new Integer(123);

boolean b1 = n instanceof Integer; // true，因为n是Integer类型

boolean b2 = n instanceof Number; // true，因为n是Number类型的子类

boolean b3 = n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class

boolean b4 = n.getClass() == Number.class; // false，因为Integer.class!=Number.class

用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。

（2）利用反射，获取类的Class对象，并访问/修改类的字段

Class类提供了以下几个方法来获取字段：

  • Field getField(name)：根据字段名获取某个public的field（包括父类）
  • Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类）
  • Field[] getFields()：获取所有public的field（包括父类）
  • Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）

例子：首先获取Student的Class实例，然后，分别获取public字段、继承的public字段以及private字段

public class Main {

    public static void main(String[] args) throws Exception {

Student  s = new Student (100);

        Class stdClass = s.getClass();

        // 获取public字段"score":

        System.out.println(stdClass.getField("score"));

// 获取字段“score”的实际值

Field f = stdClass.getField("score");

f.setAccessible(true);//如果字段是private访问，则此行必须加，不然会报错。

System.out.println(stdClass.getField("score").get(stdClass));

        // 获取继承的public字段"name":

        System.out.println(stdClass.getField("name"));

        // 获取private字段"grade":

        System.out.println(stdClass.getDeclaredField("grade"));

    }

}

 

class Student extends Person {

    private int score;

    private int grade;

    public void Student (int score) {

this.score = score;   

}

}

class Person {

    public String name;

}

Field对象包含了一个字段的所有信息：

  • getName()：返回字段名称，例如，"name"；
  • getType()：返回字段类型，也是一个Class实例，例如，String.class；
  • getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义。

以String类的value字段为例，它的定义是：

public final class String {

    private final byte[] value;

}

我们用反射获取该字段的信息，代码如下：

Field f = String.class.getDeclaredField("value");

f.getName(); // "value"

f.getType(); // class [B 表示byte[]类型

int m = f.getModifiers();

Modifier.isFinal(m); // true

Modifier.isPublic(m); // false

Modifier.isProtected(m); // false

Modifier.isPrivate(m); // true

Modifier.isStatic(m); // false

反射是一种非常规的用法，使用反射，首先代码非常繁琐，其次，它更多地是给工具或者底层框架来使用，目的是在不知道目标实例任何信息的情况下，获取特定字段的值。此外，setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全。

通过Field实例既然可以获取到指定实例的字段值，自然也可以设置字段的值。

设置字段值是通过Field.set(Object, Object)实现的，其中第一个Object参数是指定的实例，第二个Object参数是待修改的值。

（3）利用反射，调用类的方法

可以通过Class实例获取所有Method信息。Class类提供了以下几个方法来获取Method：

  • Method getMethod(name, Class...)：获取某个public的Method（包括父类）下·
  • Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
  • Method[] getMethods()：获取所有public的Method（包括父类）
  • Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）

例如：分别获取public方法、继承的public方法以及private方法

public class Main {

    public static void main(String[] args) throws Exception {

        Class stdClass = Student.class;

        // 获取public方法getScore，参数为String:

        System.out.println(stdClass.getMethod("getScore", String.class));

        // 获取继承的public方法getName，无参数:

        System.out.println(stdClass.getMethod("getName"));

        // 获取private方法getGrade，参数为int:

        System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));

    }

}

class Student extends Person {

    public int getScore(String type) {

        return 99;

    }

    private int getGrade(int year) {

        return 1;

    }

}

class Person {

    public String getName() {

        return "Person";

    }

}

1）调用普通方法

public class Main {

    public static void main(String[] args) throws Exception {

        // String对象:

        String s = "Hello world";

        // 获取String substring(int)方法，参数为int:

        Method m = String.class.getMethod("substring", int.class);

        // 在s对象上调用该方法并获取结果:

        String r = (String) m.invoke(s, 6);

        // 打印调用结果:

        System.out.println(r);

    }

}

对Method实例调用invoke就相当于调用该方法，invoke的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。

2）调用静态方法

public class Main {

    public static void main(String[] args) throws Exception {

        // 获取Integer.parseInt(String)方法，参数为String:

        Method m = Integer.class.getMethod("parseInt", String.class);

        // 调用该静态方法并获取结果:

        Integer n = (Integer) m.invoke(null, "12345");

        // 打印调用结果:

        System.out.println(n);

    }

}

如果获取到的Method表示一个静态方法，调用静态方法时，由于无需指定实例对象，所以invoke方法传入的第一个参数永远为null。

3）调用private/protected方法

public class Main {

    public static void main(String[] args) throws Exception {

        Person p = new Person();

        Method m = p.getClass().getDeclaredMethod("setName", String.class);

        m.setAccessible(true);

        m.invoke(p, "Bob");

        System.out.println(p.name);

    }

}

 

class Person {

    String name;

    private void setName(String name) {

        this.name = name;

    }

}

和Field类似，对于非public方法，我们虽然可以通过Class.getDeclaredMethod()获取该方法实例，但直接对其调用将得到一个IllegalAccessException。为了调用非public方法，我们通过Method.setAccessible(true)允许其调用；setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全。

4）调用多态方法

public class Main {

    public static void main(String[] args) throws Exception {

        // 获取Person的hello方法:

        Method h = Person.class.getMethod("hello");

        // 对Student实例调用hello方法:

        h.invoke(new Student());

    }

}

 

class Person {

    public void hello() {

        System.out.println("Person:hello");

    }

}

 

class Student extends Person {

    public void hello() {

        System.out.println("Student:hello");

    }

}

使用反射调用方法时，仍然遵循多态原则：即总是调用实际类型的覆写方法（如果存在）

5）调用构造方法：用来创建类的实例

如果通过反射来创建新的实例，可以调用Class提供的newInstance()方法：

Person p = Person.class.newInstance();

调用Class.newInstance()的局限是，它只能调用该类的public无参数构造方法。如果构造方法带有参数，或者不是public，就无法直接通过Class.newInstance()来调用。

为了调用任意的构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例。Constructor对象和Method非常类似，不同之处仅在于它是一个构造方法，并且，调用结果总是返回实例。

通过Class实例获取Constructor的方法如下：

  • getConstructor(Class...)：获取某个public的Constructor；
  • getDeclaredConstructor(Class...)：获取某个Constructor；
  • getConstructors()：获取所有public的Constructor；
  • getDeclaredConstructors()：获取所有Constructor。

注意Constructor总是当前类定义的构造方法，和父类无关，因此不存在多态的问题。

调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问。setAccessible(true)可能会失败。

例子：

public class Main {

    public static void main(String[] args) throws Exception {

        // 获取构造方法Integer(int):

        Constructor cons1 = Integer.class.getConstructor(int.class);

        // 调用构造方法:

        Integer n1 = (Integer) cons1.newInstance(123);

        System.out.println(n1);

 

        // 获取构造方法Integer(String)

        Constructor cons2 = Integer.class.getConstructor(String.class);

        Integer n2 = (Integer) cons2.newInstance("456");

        System.out.println(n2);

    }

}

6）获取Class对象的继承关系

通过Class对象可以获取继承关系：

  • Class getSuperclass()：获取父类类型；
  • Class[] getInterfaces()：获取当前类实现的所有接口。
public class Main {

    public static void main(String[] args) throws Exception {

        Class s = Integer.class.getSuperclass();

        Class[] is = s.getInterfaces();

        for (Class i : is) {

            System.out.println(i);

        }

    }

}

对所有interface的Class调用getSuperclass()返回的是null，获取接口的父接口要用getInterfaces()，如果一个类没有实现任何interface，那么getInterfaces()返回空数组。

当我们判断一个实例是否是某个类型时，正常情况下，使用instanceof操作符：

Object n = Integer.valueOf(123);

boolean isDouble = n instanceof Double; // false

boolean isInteger = n instanceof Integer; // true

boolean isNumber = n instanceof Number; // true

boolean isSerializable = n instanceof java.io.Serializable; // true

 

如果是两个Class实例，要判断一个向上转型是否成立，可以调用isAssignableFrom()：

// Integer i = ?

Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer

// Number n = ?

Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number

// Object o = ?

Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object

// Integer i = ?

Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

 

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java JVM
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入