Java 之反射

目录

• 反射
  • 一、通过反射获取 class 的四种方法
  • 二、反射中访问字段
  • 三、获取反射的方法
  • 四、反射调用构造方法
  • 五、反射获取继承关系

反射

概念：通过Classs实例获取class信息的方法称为反射

一、通过反射获取 class 的四种方法

    /**
     * 通过反射获取class实例的方法有四种：
     */
    public static void f() {

        // 方法一：直接通过一个class的静态变量class获取：
        // 1. 知道具体类的情况下可以使用：
        Class cls = String.class;

        // 方法二：如果我们有一个实例变量，可以通过该实例变量提供getClass（）方法获取：
        String s = "hello";
        Class clss = s.getClass();

        // 方法三： 如果知道一个class 的完整类型，可以通过静态方法class.forName（）获取
        try {
            Class cls1 = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
         // 方式四：通过类加载器直接获取
        Object tmp = ClassLoader.getSystemClassLoader().loadClass("com.liaoxuefeng.eReflection.ReflectionDemo");
        System.out.println("方式四： " + tmp);

    }

/**
     * class 中常用的方法有：
     *
     * @param cls
     */
    public static void printClassInfo(Class cls) {
        System.out.println("cls.getName() = " + cls.getName());
        System.out.println("cls.getSimpleName() = " + cls.getSimpleName());

        if (cls.getPackage() != null) {
            System.out.println("cls.getPackage().getName() = " + cls.getPackage().getName());
        }

        System.out.println("cls.isInterface() = " + cls.isInterface());
        System.out.println("cls.isEnum() = " + cls.isEnum());
        System.out.println("cls.isArray() = " + cls.isArray());
        System.out.println("cls.isPrimitive() = " + cls.isPrimitive());

    }

 public static void main(String[] args) {

        printClassInfo("".getClass());
        printClassInfo(Runnable.class);
        printClassInfo(java.time.Month.class);
        printClassInfo(String[].class);
        printClassInfo(int.class);

   



    }

二、反射中访问字段

    /**
     * CLass 类提供了以下几种方法来获取字段：
     * 1、Field getField(name)：根据字段名获取某个public的field(包括父类)
     * 2、Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类）
     * 3、Field getFields(): 获取所有public的field（包括父类）
     * 4、Field[] getDeclaredFields():获取当签类的所有field
     */
    public static void getFields() throws NoSuchFieldException {

        Class stdClass = Student.class;

        // 获取public 字段 "score"
        System.out.println("stdClass.getField(\"score\") = " + stdClass.getField("score"));

        // 获取student 中的"grade"
        System.out.println("stdClass.getDeclaredField(\"grade\") = " + stdClass.getDeclaredField("grade")); // class [B 表示byte[]类型

        System.out.println("stdClass.getFields() = " + Arrays.toString(stdClass.getFields()));

        System.out.println("stdClass.getDeclaredFields() = " + Arrays.toString(stdClass.getDeclaredFields()));
    }

    /**
     * 一个Field对象包含一个字段的所有信息：
     * 1、getName（）：返回字段名称，例如，"name"
     * 2、getType():返回字段类型，也是一个Class实例，例如：String.class;
     * 3、getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义
     */
    public static void fieldClass() throws NoSuchFieldException {

        Field field = String.class.getDeclaredField("value");
        System.out.println("field.getName() = " + field.getName());
        System.out.println("field.getType() " + field.getType());

        int m = field.getModifiers();
        System.out.println("m = " + m);
        System.out.println("Modifier.isFinal(m) = " + Modifier.isFinal(m));
        System.out.println("Modifier.isPublic(m) = " + Modifier.isPublic(m));
        System.out.println("Modifier.isProtected(m) = " + Modifier.isProtected(m));
        System.out.println("Modifier.isPrivate(m) = " + Modifier.isPrivate(m));
        System.out.println("Modifier.isStatic(m) = " + Modifier.isStatic(m));
    }

    /**
     * 获取具体值
     * 通过Field对象的get(Object)方法可以获取字段的当前值：
     */
    public static void getFieldValue() throws NoSuchFieldException, IllegalAccessException {

        Person1 p = new Person1("xiaoming");
        Class c = p.getClass();
        Field field = c.getDeclaredField("name");
        System.out.println("field = " + field);
        field.setAccessible(true); // Field.setAccessible(true)的意思是，别管这个字段是不是public，一律允许访问。

        Object value = field.get(p); // 根据实例获取字段值
        System.out.println("value = " + value);
    }

    /**
     * 设置字段值 <br/>
     * 通过Field实例既然可以获取到指定实例的字段值，自然也可以设置字段的值。<br/>
     * 设置字段值是通过Field.set(Object, Object)实现的，其中第一个Object参数是指定的实例，第二个Object参数是待修改的值。示例代码如下
     *
     * @param args
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    public static void setFieldValue() throws NoSuchFieldException, IllegalAccessException {

        Person3 person3 = new Person3("xiao ming");
        System.out.println("person3.getName() = " + person3.getName());
        Class c = person3.getClass();
        Field field = c.getDeclaredField("name");
        field.setAccessible(true);
        field.set(person3, "xiao  bai");
        System.out.println("Person3 = " + person3.getName());


    }

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {

        getFields();
        fieldClass();
        getFieldValue();
        setFieldValue();
    }

三、获取反射的方法

 /**
     * 获取Method的几种方法：
     * Class类提供以下几种方法获取Method:
     * 1、Method  getMethod(name,Class ，，，)： 获取某个public的method（包括父类）
     * 2、Method  getMethods() : 获取所有public 的Menthod（包括父类）
     * 2、Method getDeclareMethods() : 获取当前类的所有Menthod，包含括private方法 （不包括父类）
     * 3、Method getDeclaredMethod(name.Class ...):获取当前类的某个method，包含括private方法（不包括父类）
     **/
    public static void getMethodWays() throws NoSuchMethodException {

        Class stdClass = Student4.class;
        // 获取private方法getScore，参数为String
        System.out.println("stdClass.getMethod(\"getScore\", String.class) = " + stdClass.getMethod("getScore", String.class));
        // 获取继承的public getName 方法，无参数
        System.out.println("stdClass.getMethod(\"getName\") = " + stdClass.getMethod("getName"));
        // 获取private方法getGrade，参数为int:
        System.out.println("stdClass.getDeclaredMethod(\"getGrade\", int.class) = " + stdClass.getDeclaredMethod("getGrade", int.class));
        // 获取所有public 的Menthod（包括父类）
        System.out.println("stdClass.getMethods() = " + Arrays.toString(stdClass.getMethods()));
        // 获取当前类中所有方法，包括private方法
        System.out.println("stdClass.getDeclaredMethods() = " + Arrays.toString(stdClass.getDeclaredMethods()));
    }

    /**
     * 反射 Methond 里面常用的一些方法
     * * 一个Menthod 对象可以包含一个方法的所有信息：
     * * 1、getName() 返回方法，例如："getScore"
     * * 2、getReturnType(): 返回方法返回值类型，也是一个Class类型，例如：String.class
     * * 3、getParameterType():返回方法的参数类型，是一个Class数据，例如：{String.class,int,class}
     * * 4、getModifiers():返回方法的修饰符，它是一个int,不同的bit有不同的含义
     *
     * @throws NoSuchMethodException
     */
    public static void methodClass() throws NoSuchMethodException {
        // String对象:
        String s = "Hello world";
        // 获取String substring(int)方法，参数为int:
        Method m = String.class.getMethod("substring", int.class);

        System.out.println("m.getName() = " + m.getName());
        System.out.println("m.getReturnType() = " + m.getReturnType());
        System.out.println("m.getParameterTypes() = " + Arrays.toString(m.getParameterTypes()));
        System.out.println("m.getModifiers() = " + m.getModifiers());
    }

    /**
     * 使用反射调用方法的实际应用
     * 核心就是invoke() 方法调用
     * invoke 需要传入一个实例对象，对Method实例调用invoke就相当于调用该方法，invoke的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。
     */
    public static void methodsScenarios() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        // 原来实现逻辑
        String s = "Hello world";
        String r = s.substring(6); // "world"
        System.out.println("r = " + r);

        // 使用反射实现逻辑 
        //  方法一：反射传一个参数
        Method m = String.class.getMethod("substring", int.class);
        // 在s对象上调用该方法并获取结果:
        // invoke 需要传入一个实例对象
        // 对Method实例调用invoke就相当于调用该方法，invoke的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。
        String r1 = (String) m.invoke(s, 6);
        System.out.println("反射调用一个参数：" + r1);

        // 方法二：反射传多个参数
        // 获取String substring(int,int)方法，参数为int,int:
        Object o1 = String.class.getMethod("substring", int.class, int.class).invoke(s, 0, 6);
        System.out.println("反射调用多个参数：" + o1);

        // 调用public方法
        // 如果获取的方法是静态方法，则invoke方法传入的第一个参数是null，后面的可变参数要与方法参数一致
        Method method = Integer.class.getMethod("parseInt", String.class);
        Object o = method.invoke(null, "123");
        System.out.println("o = " + o);

        // 调用非public方法
        // 先使用 Class.getDeclaredMethod()获取该方法实例，然后，用Method.setAccessible(true)允许其调用
        Student4 s4 = new Student4();
        Method m1 = s4.getClass().getDeclaredMethod("getGrade", int.class);
        m1.setAccessible(true);
        m1.invoke(s4, 1);
    }


    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        getMethodWays();
        methodClass();
        methodsScenarios();


    }

四、反射调用构造方法

public class TestConstructionMethod {

    public static void f1() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        // 正常创建实例
        Person p = new Person();

        // 反射创建实例
        Person person = Person.class.newInstance();

    }

    /**
     * 使用Constuctor对象，调用，返回实例
     * <p>
     * 通过Class实例获取Constructor的方法如下：
     * 1、getConstructor(Class...)：获取某个public的Constructor；
     * 2、getDeclaredConstructor(Class...)：获取某个Constructor；
     * 3、getConstructors()：获取所有public的Constructor；
     * 4、getDeclaredConstructors()：获取所有Constructor。
     * 注意Constructor总是当前类定义的构造方法，和父类无关，因此不存在多态的问题。
     * <p>
     * <p>
     * Constructor对象封装了构造方法的所有信息；
     * <p>
     * 通过Class实例的方法可以获取Constructor实例：getConstructor()，getConstructors()，getDeclaredConstructor()，getDeclaredConstructors()；
     * <p>
     * 通过Constructor实例可以创建一个实例对象：newInstance(Object... parameters)； 通过设置setAccessible(true)来访问非public构造方法。
     * <p>
     * 调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问。setAccessible(true)可能会失败
     */
    public static void f2() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 获取构造方法 Interger(int)
        Constructor<Integer> constructor = Integer.class.getConstructor(int.class);
        // 调用构造方法
        Integer i = constructor.newInstance(123);

        System.out.println("i = " + i);
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        f1();
        f2();


    }

}

五、反射获取继承关系

public class TestExtends {

    /**
     * 使用反射获取实class的三种方式
     */
    public static void f1() throws ClassNotFoundException {
        // 方式一： 使用.class
        Class<String> stringClass = String.class;

        // 方式二： 使用getCLass()
        String s = "Hello";
        Class cls = s.getClass();

        // 方式三：class.forName(""),传入完整的Class 类名
        Class<?> aClass = Class.forName("java.lang.String");

    }

    /**
     * 获取父类类型
     * 1、使用getSuperclass()方法
     * 2、getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型
     * 过Class对象可以获取继承关系：
     * <p>
     * Class getSuperclass()：获取父类类型；
     * Class[] getInterfaces()：获取当前类实现的所有接口。
     * 通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现。
     */
    // 获取父类
    public static void f2() {

        Class<Integer> i = Integer.class;
        Class<? super Integer> s = i.getSuperclass();
        System.out.println("s = " + s);
        Class<? super Integer> s1 = s.getSuperclass();
        System.out.println("s1 = " + s1);
        System.out.println("s1.getSuperclass() = " + s1.getSuperclass());

    }

    // 获取Interface
    // getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型：
    // Class[] getInterfaces()：获取当前类实现的所有接口。
    public static void f3() {
        Class<Integer> s = Integer.class;
        Class<?>[] interfaces = s.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("anInterface = " + anInterface);
        }
        System.out.println(java.io.DataInputStream.class.getSuperclass());// java.io.FilterInputStream，因为DataInputStream继承自FilterInputStream
        System.out.println(java.io.Closeable.class.getSuperclass());  // null，对接口调用getSuperclass()总是返回null，获取接口的父接口要用getInterfaces()
        System.out.println(java.io.Closeable.class.getInterfaces()); // 返回继承的接口

    }

    // 继承关系
    // 通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现。
    public static void f4() {
        Class n = Integer.class;
/*      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
    }

    public static void main(String[] args) throws ClassNotFoundException {
        f1();
        f2();
        f3();
        f4();


    }

}