Java反射_python_内存溢出

文章目录

前言
一、反射整体概念介绍
- 1、定义
- 2、为什么有反射
二、Class类
- 1.class本质
- 2、class在JVM中的执行过程
- 3、通过`Class`实例获取`class`信息
- 4、动态加载
三、访问字段
- 1、访问字段的`field`
- 2、访问字段的值
- 3、修改字段的值
四、访问方法
- 1、获取方法信息
- 2、调用方法
- 3、调用静态方法
- 4、调用非public方法
- 5、多态
五、调用构造方法
六、获取继承关系
- 1、获取父类的Class
- 2、获取interface
总结

前言

本人计算机小白一枚，写博客的原因一是为了让自己能够更好地理解知识点，加强记忆，二是为了让有需要的同学康康，三是为了能够结交到有相同兴趣的小伙伴，大家一起加油！！！然后本博客只是对自己在教程中不熟悉的地方做一个记录，所以并不全面。

提示：以下是本篇文章正文内容，下面案例可供参考

一、反射整体概念介绍 1、定义

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

2、为什么有反射

正常情况下，如果我们要调用一个对象的方法或者是一个对象的字段，一般会传入一个对象实例

import com.example.Javalxf.Person;

public class Main {
	String getFullName(Person p) {
		return p.getFirstName() + " " +p.getLastName();
	}
}

但是如果没有Person这个类的信息，只有一个Object实例怎么办，强制转换是一种办法，但是它仍然需要引用Person类。所以，反射是为了解决在运行期，对某个实例一无所知的情况下，如何调用其方法。

二、Class类 1.class本质

首先我们知道，除了int、float、double等基本数据类型，Java的其他类型全部都是class(包括interface)。仔细思考，我们就会发现，class(包括interface)的本质就是一种数据类型，只不过是我们自己设计的一个数据类型。

2、class在JVM中的执行过程

class是在JVM的执行过程中动态加载的，JVM每次读取到一个新的class类型时，就会将其加载进内存，每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。

注意！！！

这里的Class类型是一个名字叫做Class的class

public final class Class {
    private Class() {}
}

以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：

Class cls = new Class(String);

所以，JVM中的每个Class实例都指向一个数据类型（class或interface）：

一个Class实例包含了该class的所有完整信息：

3、通过Class实例获取class信息

由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。

那我我们首先要做的就是获取某个Class实例，那么怎么获取呢，有三个方法：
1）直接通过一个class的静态变量class获取

Class cls = String.class;

2）如果我们有一个实例变量，也可以通过该实例变量提供的getClass()方法获取：

String s = "Hello";
Class cls = s.getClass();

3）如果知道一个class的完整类名，也可以通过静态方法Class.forName()获取：

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

因为一个数据类型对应的Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。

说了这么多方法，该回到正题了，现在已经拿到某个Object了，我们可以通过反射获取该Object的class信息：

void printObjectInfo(Object obj) {
    Class cls = obj.getClass();
}

4、动态加载

动态加载的意思就是说，JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用到class时才加载。

三、访问字段 1、访问字段的field

首先，让我们来了解一下一个字段的field到底是什么。
实际上一个Field对象包含了一个字段的所有信息：
getName()：返回字段名称，例如：“name”；
getType()：返回字段类型，也是一个Class实例，例如,String.Class；
getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义。

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

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

public class Main {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        // 获取public字段"score":
        System.out.println(stdClass.getField("score"));
        // 获取继承的public字段"name":
        System.out.println(stdClass.getField("name"));
        // 获取private字段"grade":
        System.out.println(stdClass.getDeclaredField("grade"));
    }
}

class Student extends Person {
    public int score;
    private int grade;
}

class Person {
    public String name;
}

结果类似：

public int Student.score
public java.lang.String Person.name
private int Student.grade

2、访问字段的值

对于一个Person实例，我们可以先拿到name字段对应的Field，再获取这个实例的name字段的值：

import java.lang.reflect.Field;
public class Main {

    public static void main(String[] args) throws Exception {
        Object p = new Person("Xiao Ming");
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        Object value = f.get(p);
        System.out.println(value); // "Xiao Ming"
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

上述代码先获取Class实例，再获取Field实例，然后，用Field.get(Object)获取指定实例的指定字段的值。
不出意外运行会报错，因为name是一个private字段，正常情况下，Main类无法访问Person类的private字段，要修复错误，可以将private改为’public’，或者在调用Object value = f.get(p)前，先写一句：f.setAccessible(true);
调用Field.setAccessible(true)的意思是，别管这个字段是不是public，一律允许访问。

3、修改字段的值

通过Field实例既然可以获取到指定实例的字段值，自然也可以设置字段的值。
设置字段值是通过Field.set(Object, Object)实现的，其中第一个Object参数是指定的实例，第二个Object参数是待修改的值。

import java.lang.reflect.Field;
public class Main {

    public static void main(String[] args) throws Exception {
        Person p = new Person("Xiao Ming");
        System.out.println(p.getName()); // "Xiao Ming"
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);
        f.set(p, "Xiao Hong");
        System.out.println(p.getName()); // "Xiao Hong"
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

四、访问方法 1、获取方法信息

我们已经能通过Class实例获取所有Field对象，同样的，可以通过Class实例获取所有Method信息。Class类提供了以下几个方法来获取Method：

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

结果为

public int Student.getScore(java.lang.String)
public java.lang.String Person.getName()
private int Student.getGrade(int)

一个Method对象包含一个方法的所有信息：

2、调用方法

获取到一个Method对象后，就可以对它进行调用。

String s = "Hello world";
String r = s.substring(6); // "world"

如果使用反射来调用substring方法，需要以下代码：

import java.lang.reflect.Method;
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的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。

3、调用静态方法

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

4、调用非public方法

和Field类似，对于非public方法，我们虽然可以通过Class.getDeclaredMethod()获取该方法实例，但直接对其调用将会出错，为了调用非public方法，我们通过Method.setAccessible(true)允许其调用。

5、多态

有时候会有这样一种情况，一个Person类定义了hello()方法，并且它的子类也覆写了hello()方法，那么从Person.class获取的Method，作用于Student实例时，调用的方法到底是哪一个？
结果是：使用反射调用方法时，仍然遵循多态原则：即总是调用实际类型的覆写方法（如果存在）。

五、调用构造方法

通过反射来创建新的实例，可以调用Class提供的newInstance()方法，但是它只能调用该类的public无参数构造方法。
为了可以调用任意的构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例，Constructor对象和Method非常类似，不同之处仅在于它是一个构造方法，并且，调用结果总是返回实例。
通过Class实例获取Constructor的方法如下：

注意Constructor总是当前类定义的构造方法，和父类无关，因此不存在多态的问题。
调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问。setAccessible(true)可能会失败。

六、获取继承关系 1、获取父类的Class

示例代码如下：

public class Main {
    public static void main(String[] args) throws Exception {
        Class i = Integer.class;
        Class n = i.getSuperclass();
        System.out.println(n);
        Class o = n.getSuperclass();
        System.out.println(o);
        System.out.println(o.getSuperclass());
    }
}

运行上述代码，可以看到，Integer的父类类型是Number，Number的父类是Object，Object的父类是null，Object的父类是null，除Object外，其他任何非interface的Class都必定存在一个父类类型。

2、获取interface

由于一个类可能实现一个或多个接口，通过Class我们就可以查询到实现的接口类型。例如，查询Integer实现的接口：

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
        Class s = Integer.class;
        Class[] is = s.getInterfaces();
        for (Class i : is) {
            System.out.println(i);
        }
    }
}

要特别注意：getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型。

总结

提示：这里对文章进行总结：
例如：以上就是关于反射在Java中的一些解释。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/797076.html

Java反射

发表评论

评论列表（0条）