Java反射超详解✌

Posted 2021-09-07 LL.LEBRON

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java反射超详解✌相关的知识，希望对你有一定的参考价值。

文章目录

Java反射超详解✌

Java反射超详解✌

1.反射基础

Java反射机制是在程序的运行过程中，对于任何一个类，都能够知道它的所有属性和方法；对于任意一个对象，都能够知道它的任意属性和方法，这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

Java反射机制主要提供以下这几个功能：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所有的成员变量和方法
在运行时调用任意一个对象的方法

1.1Class类

Class类，Class类也是一个实实在在的类，存在于JDK的java.lang包中。Class类的实例表示java应用运行时的类(class ans enum)或接口(interface and annotation)（每个java类运行时都在JVM里表现为一个class对象，可通过类名.class、类型.getClass()、Class.forName("类名")等方法获取class对象）。数组同样也被映射为为class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 class 对象。

到这我们也就可以得出以下几点信息：

Class类也是类的一种，与class关键字是不一样的。
手动编写的类被编译后会产生一个Class对象，其表示的是创建的类的类型信息，而且这个Class对象保存在同名.class的文件中(字节码文件)。
每个通过关键字class标识的类，在内存中有且只有一个与之对应的Class对象来描述其类型信息，无论创建多少个实例对象，其依据的都是用一个Class对象。
Class类只存私有构造函数，因此对应Class对象只能有JVM创建和加载。
Class类的对象作用是运行时提供或获得某个对象的类型信息，这点对于反射技术很重要(关于反射稍后分析)。

1.2类加载

类加载机制流程
类的加载

注：详细的类加载内容，看JVM板块。

2.反射的使用

2.1Class对象的获取

在类加载的时候，jvm会创建一个class对象。class对象可以说是反射中最常见的。

获取class对象的方式的主要三种：

根据类名：类名.class
根据对象：对象.getClass()
根据全限定类名：Class.forName(全限定类名)


public class demo1Main1 {
    public static void main(String[] args) throws Exception {
        //获取Class对象的三种对象
        System.out.println("根据类名：\\t" + User.class);
        System.out.println("根据对象：\\t" + new User().getClass());
        System.out.println("根据全限定类名：\\t" + Class.forName("demo1.User"));
        //常用的方法
        Class<User> userClass = User.class;
        System.out.println("获取全限定类名：\\t" + userClass.getName());
        System.out.println("获取类名：\\t" + userClass.getSimpleName());
        System.out.println("实例化：\\t" + userClass.newInstance());

    }
}

输出结果：

根据类名：	class demo1.User
根据对象：	class demo1.User
根据全限定类名：	class demo1.User
获取全限定类名：	demo1.User
获取类名：	User
实例化：	User{name='init', age=0}

再来看看Class类的方法：

toString()
```
public String toString() {
    return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
        + getName();
}
```
toString()方法能够将对象转换为字符串，toString()首先判断Class类型是否是接口类型，也就是说普通类和接口都能用Class对象表示，然后在判断是否是基本数据类型，这里判断的都是基本数据类型和包装类，还有void类型。
getName()

获取类的全限定名称。（包括包名）即类的完整名称。
- 如果是引用类型。比如 String.class.getName()→java.lang.String
- 如果是基本数据类型。比如 byte.class.getName()→byte
- 如果是数组类型。比如 new Object[3].getClass().getName()→[Ljava.lang.Object;
getSimpleName()

获取类名（不包括包名）。
getCanonicalName()

获取全限定的类名(包括包名)。
toGenericString()

返回类的全限定名称，而且包括类的修饰符和类型参数信息。
forName()

根据类名获得一个Class对象的引用，这个方法会使类对象进行初始化。

例如：Class t = Class.forName("java.lang.Thread")就能够初始化一个Thread线程对象。

在Java中，一共有三种获取类实例的方式：
- Class.forName(java.lang.Thread)
- Thread.class
- thread.getClass()
newInstance()
创建一个类的实例，代表着这个类的对象。上面forName()方法对类进行初始化，newInstance方法对类进行实例化。使用该方法创建的类，必须带有无参的构造器。
getClassLoader()

获取类加载器对象。
getInterfaces()

获取当前类实现的类或是接口，可能是多个，所以返回的是Class数组。
isInterface()

判断Class对象是否是表示一个接口。
getFields()

获得某个类的所有的公共（public）的字段，包括继承自父类的所有公共字段。类似的还有getMethods和getConstructors。
getDeclaredFields

获得某个类的自己声明的字段，即包括public、private和proteced，默认但是不包括父类声明的任何字段。类似的还有getDeclaredMethods和getDeclaredConstructors。

getName、getCanonicalName与getSimpleName的区别：

getSimpleName：只获取类名.
getName：类的全限定名，jvm中Class的表示，可以用于动态加载Class对象，例如Class.forName。
getCanonicalName：返回更容易理解的表示，主要用于输出（toString）或log打印，大多数情况下和getName一样，但是在内部类、数组等类型的表示形式就不同了。

栗子：

package com.cry;
public class Test {
    private  class inner{
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //普通类
        System.out.println(Test.class.getSimpleName()); //Test
        System.out.println(Test.class.getName()); //com.cry.Test
        System.out.println(Test.class.getCanonicalName()); //com.cry.Test
        //内部类
        System.out.println(inner.class.getSimpleName()); //inner
        System.out.println(inner.class.getName()); //com.cry.Test$inner
        System.out.println(inner.class.getCanonicalName()); //com.cry.Test.inner
        //数组
        System.out.println(args.getClass().getSimpleName()); //String[]
        System.out.println(args.getClass().getName()); //[Ljava.lang.String;
        System.out.println(args.getClass().getCanonicalName()); //java.lang.String[]
        //我们不能用getCanonicalName去加载类对象，必须用getName
        //Class.forName(inner.class.getCanonicalName()); 报错
        Class.forName(inner.class.getName());
    }
}

2.2Constructor类及其用法

Constructor类存在于反射包(java.lang.reflect)中，反映的是Class 对象所表示的类的构造方法。

获取Constructor对象是通过Class类中的方法获取的，Class类与Constructor相关的主要方法如下：

方法返回值	方法名称	方法说明
Constructor	getConstructor(Class<?>… parameterTypes)	返回指定参数类型、具有public访问权限的构造函数对象
Constructor<?>[]	getConstructors()	返回所有具有public访问权限的构造函数的Constructor对象数组
Constructor	getDeclaredConstructor(Class<?>… parameterTypes)	返回指定参数类型、所有声明的（包括private）构造函数对象
Constructor<?>[]	getDeclaredConstructors()	返回所有声明的（包括private）构造函数对象
T	newInstance()	调用无参构造器创建此 Class 对象所表示的类的一个新实例。

栗子：

public class ConstructionTest implements Serializable {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = null;

        //获取Class对象的引用
        clazz = Class.forName("com.example.javabase.User");

        //第一种方法，实例化默认构造方法，User必须无参构造函数,否则将抛异常
        User user = (User) clazz.newInstance();
        user.setAge(20);
        user.setName("Jack");
        System.out.println(user);

        System.out.println("--------------------------------------------");

        //获取带String参数的public构造函数
        Constructor cs1 =clazz.getConstructor(String.class);
        //创建User
        User user1= (User) cs1.newInstance("hiway");
        user1.setAge(22);
        System.out.println("user1:"+user1.toString());

        System.out.println("--------------------------------------------");

        //取得指定带int和String参数构造函数,该方法是私有构造private
        Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
        //由于是private必须设置可访问
        cs2.setAccessible(true);
        //创建user对象
        User user2= (User) cs2.newInstance(25,"hiway2");
        System.out.println("user2:"+user2.toString());

        System.out.println("--------------------------------------------");

        //获取所有构造包含private
        Constructor<?> cons[] = clazz.getDeclaredConstructors();
        // 查看每个构造方法需要的参数
        for (int i = 0; i < cons.length; i++) {
            //获取构造函数参数类型
            Class<?> clazzs[] = cons[i].getParameterTypes();
            System.out.println("构造函数["+i+"]:"+cons[i].toString() );
            System.out.print("参数类型["+i+"]:(");
            for (int j = 0; j < clazzs.length; j++) {
                if (j == clazzs.length - 1)
                    System.out.print(clazzs[j].getName());
                else
                    System.out.print(clazzs[j].getName() + ",");
            }
            System.out.println(")");
        }
    }
}


class User {
    private int age;
    private String name;
    public User() {
        super();
    }
    public User(String name) {
        super();
        this.name = name;
    }

    /**
     * 私有构造
     * @param age
     * @param name
     */
    private User(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\\'' +
                '}';
    }
}

输出结果：


User{age=20, name='Jack'}
--------------------------------------------
user1:User{age=22, name='hiway'}
--------------------------------------------
user2:User{age=25, name='hiway2'}
--------------------------------------------
构造函数[0]:private com.example.javabase.User(int,java.lang.String)
参数类型[0]:(int,java.lang.String)
构造函数[1]:public com.example.javabase.User(java.lang.String)
参数类型[1]:(java.lang.String)
构造函数[2]:public com.example.javabase.User()
参数类型[2]:()

关于Constructor类本身一些常用方法如下(仅部分，其他可查API)：

方法返回值	方法名称	方法说明
Class	getDeclaringClass()	返回 Class 对象，该对象表示声明由此 Constructor 对象表示的构造方法的类,其实就是返回真实类型（不包含参数）
Type[]	getGenericParameterTypes()	按照声明顺序返回一组 Type 对象，返回的就是 Constructor对象构造函数的形参类型。
String	getName()	以字符串形式返回此构造方法的名称。
Class<?>[]	getParameterTypes()	按照声明顺序返回一组 Class 对象，即返回Constructor 对象所表示构造方法的形参类型
T	newInstance(Object… initargs)	使用此 Constructor对象表示的构造函数来创建新实例
String	toGenericString()	返回描述此 Constructor 的字符串，其中包括类型参数。

栗子：

Constructor cs3 = clazz.getDeclaredConstructor(int.class,String.class);
System.out.println("-----getDeclaringClass-----");
Class uclazz=cs3.getDeclaringClass();
//Constructor对象表示的构造方法的类
System.out.println("构造方法的类:"+uclazz.getName());

System.out.println("-----getGenericParameterTypes-----");
//对象表示此 Constructor 对象所表示的方法的形参类型
Type[] tps=cs3.getGenericParameterTypes();
for (Type tp:tps) {
    System.out.println("参数名称tp:"+tp);
}
System.out.println("-----getParameterTypes-----");
//获取构造函数参数类型
Class<?> clazzs[] = cs3.getParameterTypes();
for (Class claz:clazzs) {
    System.out.println("参数名称:"+claz.getName());
}
System.out.println("-----getName-----");
//以字符串形式返回此构造方法的名称
System.out.println("getName:"+cs3.getName());

System.out.println("-----getoGenericString-----");
//返回描述此 Constructor 的字符串，其中包括类型参数。
System.out.println("getoGenericString():"+cs3.toGenericString());

输出结果：

-----getDeclaringClass-----
构造方法的类:com.example.javabase.User
-----getGenericParameterTypes-----
参数名称tp:int
参数名称tp:class java.lang.String
-----getParameterTypes-----
参数名称:int
参数名称:java.lang.String
-----getName-----
getName:com.example.javabase.User
-----getoGenericString-----
getoGenericString():private com.example.javabase.User(int,java.lang.String)

2.3Field类及其用法

Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

同样的道理，我们可以通过Class类的提供的方法来获取代表字段信息的Field对象，Class类与Field对象相关方法如下：

方法返回值	方法名称	方法说明
Field	getDeclaredField(String name)	获取指定name名称的(包含private修饰的)字段，不包括继承的字段
Field[]	getDeclaredField()	获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段
Field	getField(String name)	获取指定name名称、具有public修饰的字段，包含继承字段
Field[]	getField()	获取修饰符为public的字段，包含继承字段

栗子：

public class ReflectField {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> clazz = Class.forName("reflect.Student");
        //获取指定字段名称的Field类,注意字段修饰符必须为public而且存在该字段,
        以上是关于Java反射超详解✌的主要内容，如果未能解决你的问题，请参考以下文章 
 java 反射代码片段
 使用java反射将派生对象传递给想要超类的方法？
 Java反射机制详解
 C#反射详解
 详解C#中的反射
 详解C#中的反射