Java基础之反射篇

“

Hello，大家好！我是老丑。今天给大家带来的知识点是反射

”

1. 反射是什么？

反射（Reflection），它允许在运行中的Java程序获取自身的信息，并且可以操作类或者对象的内部属性。

2. 反射可以做什么？

在运行的时候分析类的能力
在运行时查看对象
利用Method对象
…

3. 反射相关的类

下面会一一讲述

Class
Field
Method
Constructor

3.1 Class

Class，类对象，描述的是类的信息（注意，描述的是类，而不是对象）。

Java里面，万物皆对象。

Class 类的一些方法（列举部分）

// 构造方法，参数为ClassLoader，类加载器
private Class(ClassLoader loader) {}
// 通过Class对象创建实例，在这里使用到了泛型的知识
// 大家如果对于泛型还不太熟悉的话，可以阅读Java基础之泛型篇
public T newInstance() throws InstantiationException,IllegalAccessException{}
// 这个方法可以根据全限定类名来获取类对象（注意这是类对象）。
public static Class<?> forName(String className) throws ClassNotFoundException {}
// 判断当前的类是否是接口
public native boolean isInterface();
// 判断当前的类是否是数组类
public native boolean isArray();
// 判断当前的类是否是注解类
public boolean isAnnotation() {}
// 根据类对象获取类名
public String getName() {}
// 获取加载该类的类加载器
public ClassLoader getClassLoader() {}
// 获取父类的名称
public native Class<? super T> getSuperclass();
// 获取包名
public Package getPackage() {}
// 返回一个类数组，数组中包括该类中所有共同类和接口类的对象。
public Class<?>[] getClasses() {}
// 获取类的所有权限为public的变量（包括该类和超类或者超接口）
public Field[] getFields() throws SecurityException {}
// 获取本类的所有变量
public Field[] getDeclaredFields() throws SecurityException {}
// 获取类的所有权限为public的方法（包括该类和超类或者超接口）
public Method[] getMethods() throws SecurityException {}
// 获取本类的所有成员方法
public Method[] getDeclaredMethods() throws SecurityException {}
// 获取类的所有权限为public的构造方法
public Constructor<?>[] getConstructors() throws SecurityException {}
// 获取本类的所有构造方法
public Constructor<?>[] getDeclaredConstructors() throws SecurityException {}

3.2 Method

Method，翻译过来就是方法的意思，代表的是类的成员方法。

在函数式编程里面，方法是一等公民！

Method类的一些方法（列举部分）

// 获取方法名
public String getName() {}
// 获取返回值类型
public Class<?> getReturnType() {}
// 获取参数们的类型
public Class<?>[] getParameterTypes() {}
// 方法调用，传递参数obj就是对象本地，args就是该方法对应的参数
public Object invoke(Object obj, Object... args) {}

3.3 Field

Field，翻译过来就是字段，代表的是类的成员变量。

Field类的一些方法（列举部分）

// 获取字段的类型
public Class<?> getType() {}
// 比较方法
public boolean equals(Object obj) {}
// 获取对象obj对应的属性值
public Object get(Object obj)throws IllegalArgumentException, IllegalAccessException {}
// 设置对象obj对应的属性的值为value
public void set(Object obj, Object value) throws IllegalArgumentException, IllegalAccessException {}

3.4 Constructor

Constructor，翻译过来就是构造函数的意思，代表的就是类的构造函数。

Constructor类的一些方法（列举部分）

// 获取名称
public String getName() {}
// 获取参数们类型
public Class<?>[] getParameterTypes() {}
// 创建对应类的实例对象 initargs为参数
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException
{}

4. 反射操作

“

在这里会列举一些基本操作。

”

4.1 前提

反射的前提是我们可以拿到Class对象（类对象）。

我们通过以下几种方式来Get我们的Class对象

// 第一种
Class.forName(类名);
// 第二种，通过类来获取
Class.class;
// 第三种，通过对象的getClass方法来获取
obj.getClass();

示例

下面就是以上三种方法获取Class对象的具体示例。后续的代码只会使用第三种进行。

People people = new People("laochou", 19, 1, "IdCard");
try {
    // 第一种
 Class<?> p2 = Class.forName("cn.laochou.entity.People");
} catch (ClassNotFoundException e) {
 e.printStackTrace();
}
// 第二种
Class<?> p1 = People.class;
// 第三种
Class<?> p = people.getClass();

如果有人问起Class，这个是什么意思？，我只能说“年轻人，我劝你耗子尾汁，白嫖的Java基础之泛型篇你都不要？”。

4.2 反射的基操

声明：所有的类的字段都是为了演示目的，合理性目前暂不考虑

Animal类

package cn.laochou.entity;

public class Animal {

    private String name;

    private int age;

    private int sex;

    public String flag;

    public Animal(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public static void call() {
        System.out.println("call");
    }
    
    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", sex=" + sex +
                ", flag='" + flag + ''' +
                '}';
    }
    
}

People类

package cn.laochou.entity;

public class People extends Animal {

    private static int id = 1;
    
    public static int publicId = 2;

    private String idCard;

    public String tag;

    public People(String name, int age, int sex, String idCard) {
        super(name, age, sex);
        this.idCard = idCard;
    }
    
    private People(String name, int age, int sex) {
        super(name, age, sex);
    }

    public void sayHello() {
        System.out.println("hello");
    }

    public static void eat() {
        System.out.println("eat");
    }

    private void dance() {
        System.out.println("dance");
    }
    
    @Override
    public String toString() {
        return "People{" +
                "idCard='" + idCard + ''' +
                ", tag='" + tag + ''' +
                ", father='" + super.toString() + ''' +
                '}';
    }
}

我们今天的反射的基本操作是建立在这两个类上。

4.2.1 Main方法

public static void main(String[] args) {
    People people = new People("laochou", 19, 1, "IdCard");
    Class<?> p = people.getClass();
//    printAllPublicMethods(p);
//    printAllMethods(p);
//    printAllPublicConstructor(p);
//    printAllConstructor(p);
//    printAllPublicField(p);
//    printAllField(p);
//    createObject(p);
//    methodInvoke(p, people);
//    setFieldValue(p, people);
}

大家可以对应main方法中的调用顺序进行阅读学习。

4.2.2 打印所有权限为public的方法

/**
 * 打印所有权限为public的方法
 * @param p 类对象
 */
public static void printAllPublicMethods(Class<?> p) {
    // 获取所有公有成员方法
    Method[] publicMethods = p.getMethods();
    for(Method method : publicMethods) {
     System.out.println(method);
    }
}

效果

获取了所有公有方法（包括继承父类的）。

大家可以看到确实没有dance这个方法，因为dance方法被private修饰了

public static void cn.laochou.entity.People.eat()
public void cn.laochou.entity.People.sayHello()
public static void cn.laochou.entity.Animal.call()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

4.2.3 打印本类所有方法

public static void printAllMethods(Class<?> p) {
    // 获取所有方法
    Method[] methods = p.getDeclaredMethods();
    for(Method method : methods) {
        System.out.println(method);
    }
}

效果

public void cn.laochou.entity.People.sayHello()
public static void cn.laochou.entity.People.eat()
// 其中dance就是私有方法
private void cn.laochou.entity.People.dance()

4.2.4 打印所有权限为public的构造方法

/**
 * 打印权限为public的构造方法
 * @param p 类对象
 */
public static void printAllPublicConstructor(Class<?> p) {
 Constructor<?>[] constructors = p.getConstructors();
 for(Constructor<?> constructor : constructors) {
  System.out.println(constructor);
 }
}

效果

public cn.laochou.entity.People(java.lang.String,int,int,java.lang.String)

4.2.5 打印本类所有构造方法

/**
 * 打印所有构造方法
 * @param p 类对象
 */
public static void printAllConstructor(Class<?> p) {
    Constructor<?>[] constructors = p.getDeclaredConstructors();
    for(Constructor<?> constructor : constructors) {
        System.out.println(constructor);
    }
}

效果

public cn.laochou.entity.People(java.lang.String,int,int,java.lang.String)
// 私有构造方法
private cn.laochou.entity.People(java.lang.String,int,int)

4.2.6 打印所有权限为public的变量

/**
 * 打印所有权限为public的变量
 * @param p
 */
public static void printAllPublicField(Class<?> p) {
 Field[] fields = p.getFields();
 for(Field field : fields) {
  System.out.println(field);
 }
}

效果

tag和flag是被public修饰的。因此OK。

public static int cn.laochou.entity.People.publicId
public java.lang.String cn.laochou.entity.People.tag
public java.lang.String cn.laochou.entity.Animal.flag

4.2.7 打印本类所有变量

/**
  * 打印本类所有成员变量
  * @param p 类对象
  */
public static void printAllField(Class<?> p) {
    Field[] fields = p.getDeclaredFields();
    for(Field field : fields) {
        System.out.println(field);
    }
}

效果

private static int cn.laochou.entity.People.id
public static int cn.laochou.entity.People.publicId
private java.lang.String cn.laochou.entity.People.idCard
public java.lang.String cn.laochou.entity.People.tag

4.2.8 反射获得构造方法创建对象

public static void createObject(Class<?> p) {
    try {
        Constructor<?> constructor = p.getConstructor(String.class, int.class, int.class, String.class);
        String name = "laochou";
        int age = 19;
        int sex = 1;
        String idCard = "laochou";
        Object object = constructor.newInstance(name, age, sex, idCard);
        System.out.println(object);
    } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
        e.printStackTrace();
    }
}

效果

这里是OK 的。

People{idCard='laochou', tag='null', father='Animal{name='laochou', age=19, sex=1, flag='null'}'}

4.2.9 反射调用方法

/**
  * 通过反射来调用方法
  * @param p 类对象
  * @param obj 实例对象
  */
public static void methodInvoke(Class<?> p, Object obj) {
    try {
        Method method = p.getMethod("eat");
        method.invoke(obj);
    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
        e.printStackTrace();
    }
}

效果

调用成功

eat

4.2.10 反射来获取变量的值且设置变量的值

/**
  * 通过反射来获取变量的值且设置变量的值
  * @param p
  * @param obj
  */
public static void setFieldValue(Class<?> p, Object obj) {
    try {
        Field field = p.getField("tag");
        System.out.println(field.get(obj));
        field.set(obj, "tag-2021");
        System.out.println(obj);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        e.printStackTrace();
    }
}

效果

// 开始的值
null
// 后面设置完成之后打印的
People{idCard='IdCard', tag='tag-2021', father='Animal{name='laochou', age=19, sex=1, flag='null'}'}

5. 一些疑问或好奇？

“

不知道看到这里，大家有没有一些疑问或者好奇？

如果没有的话，我就引起大家的好奇。

”

Class对象（类对象）为什么这么强大，什么都能获取。

首先，大家得知道Class对象是怎么来的。

因为Class对象是在类加载的过程中进行创建的，这里面涉及到部分虚拟机的一些知识。

大家如果没有接触过，就可以默认为在程序运行的时候，Java就可以帮我们创建一个Class对象。（后面会在虚拟机篇详细讲）

大家如果看过让Java跑起来！这篇文章的最后一步，写一个最简单的Java程序，在javac命令运行完的时候，大家细心的话，会发现桌面上多了一个Hello.class文件。

OK，其实Class对象类对象就是加载class文件而得到的。

下面我们简单的就People.class文件进行简单分析（太多了，就保留了6行，大家可以自行操作）

cafe babe 0000 0034 004d 0a00 1500 3009
0014 0031 0900 3200 3308 0034 0a00 3500
3608 0029 0800 2a07 0037 0a00 0800 3808
0039 0a00 0800 3a0a 0008 003b 0800 3c09
0014 003d 0800 3e0a 0015 003f 0a00 0800
3f09 0014 0040 0900 1400 4107 0042 0700