[Java] - 非Java核心技术卷I笔记 - 反射（八）

左手的ㄟ右手 2023-02-25 08:54 1阅读 0赞

# 反射 #

## 来源 ##

[https://www.jianshu.com/p/9be58ee20dee][https_www.jianshu.com_p_9be58ee20dee]

## 定义 ##

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

## 反射机制的相关类 ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Class类</td> 
   <td>代表类的实体，在运行的Java应用程序中表示类和接口</td> 
  </tr> 
  <tr> 
   <td>Field类</td> 
   <td>代表类的成员变量（成员变量也称为类的属性）</td> 
  </tr> 
  <tr> 
   <td>Method类</td> 
   <td>代表类的方法</td> 
  </tr> 
  <tr> 
   <td>Constructor类</td> 
   <td>代表类的构造方法</td> 
  </tr> 
 </tbody> 
</table>

## Class类 ##

[Class][]代表类的实体，在运行的Java应用程序中表示类和接口。

*  **获得类相关的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>asSubclass(Class<u> clazz)</u></td> 
   <td>把传递的类的对象转换成代表其子类的对象</td> 
  </tr> 
  <tr> 
   <td>cast</td> 
   <td>把对象转换成代表类或是接口的对象</td> 
  </tr> 
  <tr> 
   <td>getClassLoader()</td> 
   <td>获得类的加载器</td> 
  </tr> 
  <tr> 
   <td>getClasses()</td> 
   <td>返回一个数组，数组中包含该类中所有公共类和接口类的对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredClasses()</td> 
   <td>返回一个数组，数组中包含该类中所有类和接口类的对象</td> 
  </tr> 
  <tr> 
   <td>forName(String className)</td> 
   <td>根据类名返回类的对象</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>获得类的完整路径名字</td> 
  </tr> 
  <tr> 
   <td>newInstance()</td> 
   <td>创建类的实例</td> 
  </tr> 
  <tr> 
   <td>getPackage()</td> 
   <td>获得类的包</td> 
  </tr> 
  <tr> 
   <td>getSimpleName()</td> 
   <td>获得类的名字</td> 
  </tr> 
  <tr> 
   <td>getSuperclass()</td> 
   <td>获得当前类继承的父类的名字</td> 
  </tr> 
  <tr> 
   <td>getInterfaces()</td> 
   <td>获得当前类实现的类或是接口</td> 
  </tr> 
 </tbody> 
</table>

*  **获得类中属性相关的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getField(String name)</td> 
   <td>获得某个公有的属性对象</td> 
  </tr> 
  <tr> 
   <td>getFields()</td> 
   <td>获得所有公有的属性对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredField(String name)</td> 
   <td>获得某个属性对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredFields()</td> 
   <td>获得所有属性对象</td> 
  </tr> 
 </tbody> 
</table>

*  **获得类中注解相关的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getAnnotation(Class annotationClass)</td> 
   <td>返回该类中与参数类型匹配的公有注解对象</td> 
  </tr> 
  <tr> 
   <td>getAnnotations()</td> 
   <td>返回该类所有的公有注解对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredAnnotation(Class annotationClass)</td> 
   <td>返回该类中与参数类型匹配的所有注解对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredAnnotations()</td> 
   <td>返回该类所有的注解对象</td> 
  </tr> 
 </tbody> 
</table>

*  **获得类中构造器相关的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getConstructor(Class…&lt;?&gt; parameterTypes)</td> 
   <td>获得该类中与参数类型匹配的公有构造方法</td> 
  </tr> 
  <tr> 
   <td>getConstructors()</td> 
   <td>获得该类的所有公有构造方法</td> 
  </tr> 
  <tr> 
   <td>getDeclaredConstructor(Class…&lt;?&gt; parameterTypes)</td> 
   <td>获得该类中与参数类型匹配的构造方法</td> 
  </tr> 
  <tr> 
   <td>getDeclaredConstructors()</td> 
   <td>获得该类所有构造方法</td> 
  </tr> 
 </tbody> 
</table>

*  **获得类中方法相关的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getMethod(String name, Class…&lt;?&gt; parameterTypes)</td> 
   <td>获得该类某个公有的方法</td> 
  </tr> 
  <tr> 
   <td>getMethods()</td> 
   <td>获得该类所有公有的方法</td> 
  </tr> 
  <tr> 
   <td>getDeclaredMethod(String name, Class…&lt;?&gt; parameterTypes)</td> 
   <td>获得该类某个方法</td> 
  </tr> 
  <tr> 
   <td>getDeclaredMethods()</td> 
   <td>获得该类所有方法</td> 
  </tr> 
 </tbody> 
</table>

*  **类中其他重要的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>isAnnotation()</td> 
   <td>如果是注解类型则返回true</td> 
  </tr> 
  <tr> 
   <td>isAnnotationPresent(Class&lt;? extends Annotation&gt; annotationClass)</td> 
   <td>如果是指定类型注解类型则返回true</td> 
  </tr> 
  <tr> 
   <td>isAnonymousClass()</td> 
   <td>如果是匿名类则返回true</td> 
  </tr> 
  <tr> 
   <td>isArray()</td> 
   <td>如果是一个数组类则返回true</td> 
  </tr> 
  <tr> 
   <td>isEnum()</td> 
   <td>如果是枚举类则返回true</td> 
  </tr> 
  <tr> 
   <td>isInstance(Object obj)</td> 
   <td>如果obj是该类的实例则返回true</td> 
  </tr> 
  <tr> 
   <td>isInterface()</td> 
   <td>如果是接口类则返回true</td> 
  </tr> 
  <tr> 
   <td>isLocalClass()</td> 
   <td>如果是局部类则返回true</td> 
  </tr> 
  <tr> 
   <td>isMemberClass()</td> 
   <td>如果是内部类则返回true</td> 
  </tr> 
 </tbody> 
</table>

## Field类 ##

[Field][]代表类的成员变量（成员变量也称为类的属性）。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>equals(Object obj)</td> 
   <td>属性与obj相等则返回true</td> 
  </tr> 
  <tr> 
   <td>get(Object obj)</td> 
   <td>获得obj中对应的属性值</td> 
  </tr> 
  <tr> 
   <td>set(Object obj, Object value)</td> 
   <td>设置obj中对应属性值</td> 
  </tr> 
  <tr> 
   <td>setAccessible(boolean)</td> 
   <td>设置方法的可访问性</td> 
  </tr> 
 </tbody> 
</table>

## Method类 ##

[Method][]代表类的方法。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>invoke(Object obj, Object… args)</td> 
   <td>传递object对象及参数调用该对象对应的方法</td> 
  </tr> 
  <tr> 
   <td>setAccessible(boolean)</td> 
   <td>设置方法的可访问性</td> 
  </tr> 
 </tbody> 
</table>

速度较慢，不要使用`Method`回调，推荐接口回调

## Constructor类 ##

Constructor代表类的构造方法。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>newInstance(Object... initargs)</code></td> 
   <td>根据传递的参数创建类的对象</td> 
  </tr> 
  <tr> 
   <td><code>getDeclaringClass()</code></td> 
   <td>返回一个用于描述类的对象</td> 
  </tr> 
  <tr> 
   <td><code>getExceptionTypes()</code></td> 
   <td>返回一个描述方法抛出异常类型的Class对象数组（Constructor和Method）</td> 
  </tr> 
  <tr> 
   <td><code>getModifiers()</code></td> 
   <td>一个用于描述构造器，方法或域的修饰符的整型数值。使用<code>Modifer</code>类中的方法可以分析这个返回值</td> 
  </tr> 
  <tr> 
   <td><code>getParameterTypes()</code></td> 
   <td>获取参数类型（Constructor和Method）</td> 
  </tr> 
  <tr> 
   <td><code>setAccessible(boolean)</code></td> 
   <td>设置方法的可访问性</td> 
  </tr> 
 </tbody> 
</table>

## Modifier ##

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td><code>static isXxxx(int)</code></td> 
   <td>传入<code>getModifiers()</code>方法的返回值，判断是否是某种修饰符</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td><code>static toString(int)</code></td> 
   <td>通过<code>getModifiers()</code>的值，返回对应的修饰符字符串表示</td> 
  </tr> 
 </tbody> 
</table>

public static void test5() { 
            Class<?> t = Class.forName("cc.T");
            int modifiers = t.getDeclaredMethod("getD").getModifiers();
            String s = Modifier.toString(modifiers);
            System.out.println(s);
        }

## AccessibleObject ##

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td></td> 
   <td><code>static setAccessible(AccessibleObject[] array, boolean flag)</code></td> 
   <td>批量设置<code>Accessible</code></td> 
  </tr> 
 </tbody> 
</table>

其它方法用于继承

## 示例 ##

`private`方法与属性，需通过`setAccessible()`方法来访问（在不受到安全管理器的控制时）

调用静态方法`invoke`第一个参数填`null`

package cc;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    public class A{ 
    
        public static void main(String[] args) { 
    // test1();
    // test2();
            test4();
    
        }
        //调用静态方法
        public static void test6(){ 
            Class<?> aClass = Class.forName("cc.T");
            Method p = aClass.getMethod("p");
            p.invoke(null);// 注意
        }
        //构造器反射
        public static void test5(){ 
            Class<?> t = Class.forName("cc.T");
            T o1 = (T) t.newInstance();
            Constructor<? extends T> constructor = o1.getClass().getDeclaredConstructor();
            T o2 = constructor.newInstance();//通过构造器生成对象
        }
        //反射private方法
        public static void test4() { 
            Class<?> t = Class.forName("cc.T");
            T o1 = (T) t.newInstance();
            Method print = o1.getClass().getDeclaredMethod("print");
            print.setAccessible(true);
            print.invoke(o1);
        }
        //反射private属性
        public static void test3() { 
            T t = new T();
            Class<? extends T> aClass = t.getClass();
            Field d = aClass.getDeclaredField("d");
            d.setAccessible(true);
            d.setInt(t,56);
            //d.get();
            //d.set();
            System.out.println(d.getInt(t));
        }
    
        // 通过反射修改变量（不改变访问控制）
        private static void test2(){ 
            T t = new T();
            t.setD(23);
            Class<? extends T> aClass = t.getClass();
            Method getD = aClass.getDeclaredMethod("getD");
            //第二个参数是填方法参数类型，用于重载方法辨别
            Method setD = aClass.getDeclaredMethod("setD", int.class);
            Object invoke = getD.invoke(t);
            System.out.println(invoke);
            setD.invoke(t,55);
            System.out.println(getD.invoke(t));
        }
    
        //创建新实例
        public static void test1(){ 
            Class<?> t = Class.forName("cc.T");
            T o1 = (T) t.newInstance();
            o1.setD(23);
            System.out.println(o1.getD());
        }
    }
    
    class T{ 
        public int a;
        protected int b;
        int c;
        private int d;
    
        public int getC() { 
            return c;
        }
    
        public void setC(int c) { 
            this.c = c;
        }
    
        public int getD() { 
            return d;
        }
    
        public void setD(int d) { 
            this.d = d;
        }
        private void print(){ 
            System.out.println("Private Method");
        }
        public static void p(){ 
            System.out.println("Static Method");
        }
    }

### 通过反射扩展数组 ###

如果创建的数组一开始是`Object`类型的，那么无法向下转型

public class A{ 
        public static void main(String[] args){ 
            int[] a = { 2,4,5};
            int[] b = (int[]) copyOfArray(a,6);
            System.out.println("Length: "+b.length);
            System.out.println(Arrays.toString(b));
            // Length: 6
    		// [2, 4, 5, 0, 0, 0]
        }
        public static Object copyOfArray(Object o,int newLength){ 
            Class<?> cl = o.getClass();
            if (!cl.isArray()) return null;//检测类型
            Class<?> componentType = cl.getComponentType();//获取数组内元素类型
            int lenght = Array.getLength(o);
            Object newArray = Array.newInstance(componentType,newLength);
            System.arraycopy(o, 0, newArray, 0, Math.min(lenght, newLength));
            return newArray;
        }
    }

[https_www.jianshu.com_p_9be58ee20dee]: https://www.jianshu.com/p/9be58ee20dee
[Class]: https://developer.android.google.cn/reference/java/lang/Class
[Field]: https://developer.android.google.cn/reference/java/lang/reflect/Field
[Method]: https://developer.android.google.cn/reference/java/lang/reflect/Method