Reflection：Java反射機制基礎(chǔ)

hizengzeng 發(fā)布于2019-08-15 10:44 / 2112人閱讀

摘要：反射機制是什么反射機制是在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法對于任意一個對象，都能夠調(diào)用它的任意一個方法和屬性這種動態(tài)獲取的信息以及動態(tài)調(diào)用對象的方法的功能稱為語言的反射機制反射機制能做什么反射機制主要提供了以下功

反射機制是什么

反射機制是在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調(diào)用它的任意一個方法和屬性；這種動態(tài)獲取的信息以及動態(tài)調(diào)用對象的方法的功能稱為java語言的反射機制

反射機制能做什么

反射機制主要提供了以下功能：

在運行時判斷任意一個對象所屬的類

在運行時構(gòu)造任意一個類的對象

在運行時判斷任意一個類所具有的成員變量和方法

在運行時調(diào)用任意一個對象的方法

生成動態(tài)代理

反射機制的相關(guān)API 通過一個對象獲得完整的包名和類名

    @Test
    public void getReflectionName() {
        String str = new String();
        System.out.println(str.getClass().getName()); // java.lang.String
        System.out.println(str.getClass().getSimpleName()); // String
    }

實例化Class類對象(三種方式)

    @Test
    public void getInitClazz() {

        try {
            // 方式一：
            Class clazz_1 = Class.forName("java.lang.String");
            // 方式二：
            Class clazz_2 = new String().getClass();
            // 方式三：
            Class clazz_3 = String.class;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

獲取一個對象的父類與實現(xiàn)的接口

    @Test
    public void getParentAndIntefaces() {

        try {
            Class clazz = Class.forName("java.lang.String");
            // 取得父類
            Class parentClass = clazz.getSuperclass();
            System.out.println("clazz的父類為：" + parentClass.getName());// clazz的父類為： java.lang.Object
            
            // 獲取所有的接口
            Class intes[] = clazz.getInterfaces();
            System.out.println("clazz實現(xiàn)的接口有：");
            for (int i = 0; i < intes.length; i++) {
                System.out.println((i + 1) + "：" + intes[i].getName());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通過反射獲取屬性

    @Test
    public void getFieldsByReflect() {

        try {
                Class clazz = String.class ;
                // 取得本類的全部屬性
                Field[] declaredFields = clazz.getDeclaredFields(); 
                // 取得實現(xiàn)的接口或者父類的屬性
                Field[] fields = clazz.getFields();
                
                //遍歷本類屬性
                for (Field field : declaredFields) {
                    // 權(quán)限修飾符
                    int mo = field.getModifiers();
                    String priv = Modifier.toString(mo);
                    // 屬性類型
                    Class type = field.getType();
                    System.out.println(priv + " " + type.getName() + " " + field.getName() + ";");
                }
                
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通過反射獲取方法函數(shù)

    @Test
    public void getMethodsByReflect() {

        try {
            Class clazz = String.class ;
            // 類的所有公用（public）方法包括其繼承類的公用方法，當(dāng)然也包括它所實現(xiàn)接口的方法
            Method[] methods = clazz.getMethods();
            // 類或接口聲明的所有方法，包括公共、保護(hù)、默認(rèn)（包）訪問和私有方法，但不包括繼承的方法。當(dāng)然也包括它所實現(xiàn)接口的方法
            Method[] declaredMethods = clazz.getDeclaredMethods();
            
            //遍歷本類屬性
            for (Method method : methods) {
                // 權(quán)限修飾符
                int mo = method.getModifiers();
                String priv = Modifier.toString(mo);
                //返回值
                Class returnType = method.getReturnType();
                //方法名
                String methodName = method.getName();
                //方法參數(shù)類型
                Class[] parameterTypes = method.getParameterTypes();
                //拋出的異常
                Class[] exceptionTypes = method.getExceptionTypes();
            }
            
    } catch (Exception e) {
        e.printStackTrace();
    }
    }

通過反射獲取構(gòu)造方法

    @Test
    public void getConstructorsByReflect() {

        try {
            Class clazz = Class.forName("java.lang.String");
            
            //獲取構(gòu)造方法
            Constructor[] constructors = clazz.getConstructors();
            for (Constructor constructor : constructors) {
                
                //獲取構(gòu)造方法的參數(shù)
                Class[] parameterTypes = constructor.getParameterTypes();
                for (Class clazzType : parameterTypes) {
                    System.out.print(clazzType.getSimpleName() + "   ");
                }
                System.out.println();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通過反射機制設(shè)置屬性

    @Test
    public void oprFieldsByReflect() {

        try {
            
            Class clazz = Class.forName("java.lang.String");
            //實例化對象
            String str = new String("String");
            //可以直接對 private 的屬性賦值
            Field field = clazz.getDeclaredField("hash");
            //改變屬性
            field.setAccessible(true);
            //調(diào)用映射屬性
            field.set(str, 0);
            
            System.out.println(field.get(str));
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通過反射機制調(diào)用方法

    @Test
    public void oprMethodsByReflect() {

        try {
            Class clazz = Class.forName("java.lang.String");
            //實例化一個對象
            String str = new String("String");
            //反射出一個方法
            Method method =  clazz.getMethod("startsWith", String.class);
            //調(diào)用映射方法
            Object result = method.invoke(str, "Str");
            
            System.out.println(result);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

實例應(yīng)用 在泛型為Integer的ArrayList中存放一個String類型的對象

    /**
     * 在泛型為Integer的ArrayList中存放一個String類型的對象
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
           ArrayList list = new ArrayList();
            Method method = list.getClass().getMethod("add", Object.class);
            method.invoke(list, "Java反射機制實例");
            System.out.println(list.get(0));
    }

通過反射取得并修改數(shù)組的信息

    /**
     * 通過反射取得并修改數(shù)組的信息
     * 
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        int[] temp = { 1, 2, 3, 4, 5 };
        Class demo = temp.getClass().getComponentType();
        
        System.out.println("數(shù)組類型： " + demo.getName());
        
        System.out.println("數(shù)組長度  " + Array.getLength(temp));
        
        System.out.println("數(shù)組的第一個元素: " + Array.get(temp, 0));
        
        Array.set(temp, 0, 100);
        System.out.println("修改之后數(shù)組第一個元素為： " + Array.get(temp, 0));
    }

通過反射機制修改數(shù)組的大小

   /**
     * 通過反射機制修改數(shù)組的大小
     * 
     * @throws Exception
     */
    @Test
    public void test() throws Exception {

        int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int[] newTemp = (int[]) arrayInc(temp, 15);
        print(newTemp);
        String[] atr = { "a", "b", "c" };
        String[] str1 = (String[]) arrayInc(atr, 8);
        print(str1);
    }

    // 修改數(shù)組大小
    private static Object arrayInc(Object obj, int len) {
        Class arr = obj.getClass().getComponentType();
        Object newArr = Array.newInstance(arr, len);
        int co = Array.getLength(obj);
        System.arraycopy(obj, 0, newArr, 0, co);
        return newArr;
    }

    // 打印
    private static void print(Object obj) {
        Class c = obj.getClass();
        if (!c.isArray()) {
            return;
        }
        System.out.println("數(shù)組長度為： " + Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i) + " ");
        }
        System.out.println();
    }