【Java反射】Java 泛型基礎

gcusky發表於2019-01-19
Java反射泛型

筆記來源：IMOOC 反射

Java Reflect

綜述

  • Class類的使用
  • 方法的反射
  • 成員變數的反射
  • 建構函式的反射
  • 類載入機制

Class 類的使用

在物件導向的世界裡，萬事萬物皆物件。

  • 但在Java裡面有兩樣東西不是物件：靜態的成員、普通資料型別類（但它們有封裝類彌補）
  • 類是物件，類是 java.lang.Class 的例項物件（There is a class named Class）
package com.gcusky.reflect;

class ClassDemo {
    Foo foo = new Foo(); // Foo的例項物件
    /**
     * foo 是 Foo 類的例項物件
     * Foo 是 Class 類的例項物件，又叫類型別（class type）
     */
    // 表示1 -> 任何一個類都有一個隱含的靜態成員變數class
    Class c1 = Foo.class;
    // 表示2 -> 已知該類物件可用getClass方法獲取類型別
    Class c2 = foo.getClass();
    // 表示3 -> 用類的全稱獲取
    try {
        Class c3 = Class.forName("com.gcusky.reflect.Foo");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    // 可以通過類的類型別建立該類的例項物件
    try {
        Foo foo1 = (Foo)c1.newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}
class Foo

Java 動態載入類

Class.forName("類的全稱")

  • 不僅表示了類的類型別，還代表了動態載入類

    • 編譯時刻載入類是靜態載入類
    • 執行時刻載入類是動態載入類
class Office {
    public static void main(String[] args) {
        // new 建立物件，是靜態載入類，在編譯時就需要載入所有可能使用到的類
        if("Word".equals(args[0])) {
            Word w = new Word();
            w.start();
        }
        // Class.forName 建立物件，是動態載入類，在執行時才載入
        try {
            Class c = Class.forName(args[0])
            Word w = (Word) c.newInstance(); // 通過類型別，建立該物件
            w.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Java 獲取方法資訊

  • 基本的資料型別，void 關鍵字都存在類型別
  • java.lang.reflect.Method 封裝了關於方法的操作
package com.gcusky.reflect;
import java.lang.reflect.Method;

public class Demo {
    /**
     * 列印類的資訊，包括類的成員函式、成員變數
     * @param obj 物件
     */
    public static void printClassMessage(Object obj) {
        // 要獲取類的資訊，首先要獲取類的類型別
        Class c = obj.getClass();
        // 獲取類的全名
        String fullName = c.getName();
        /**
         * Method類：方法物件
         * 一個成員方法就是一個Method物件
         * getMethods()方法獲取的是所有的public的函式，包括父類繼承而來的
         * getDeclaredMethods() 獲取的是所有該類自己宣告的方法，不問訪問許可權
         */
        Method[] ms = c.getMethods(); // c.getDeclaredMethods();
        for (int i = 0; i < ms.length; i++) {
            // 得到方法的返回型別
            Class returnType = ms[i].getReturnType();
            // 得到方法的名稱
            String name = ms[i].getName();
            // 獲取引數型別
            Class[] paramTypes = ms[i].getParameterTypes();
        }
    }
}

Java 獲取成員變數資訊

  • 成員變數也是物件
  • java.lang.reflect.Field 封裝了關於成員變數的操作
        /**
         * 成員變數也是物件，Field封裝了關於成員變數的操作
         * getFields()獲取的是所有的public的成員變數
         * getDeclaredMethods()獲取的是所有該類自己宣告的成員變數
         */
        Field[] fs = c.getDeclaredFields(); // c.getFields();
        for (int i = 0; i < fs.length; i++) {
            // 得到成員變數的型別
            Class fieldType = fs[i].getType();
            String typeName = fieldType.getName();
            // 得到成員變數的名稱
            String fieldName = fs[i].getName();
        }

Java 獲取建構函式資訊

        /**
         * 建構函式也是物件
         * java.lang.Constructor中封裝了建構函式的資訊
         */
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            constructor.getName();
            Class[] paramType = constructor.getParameterTypes();
        }

Java 方法的反射

  1. 如何獲取某個方法：方法的名稱和方法的引數列表才能唯一決定某個方法
  2. 方法反射的操作：method.invoke(物件, 引數列表) 
class A {
    public void print(int a, int b) {
        System.out.println(a + b);
    }
}
A a = new A();
Class c = a.getClass();
try {
    // Method m = c.getMethod("print", new Class[]{int.class, int.class});
    Method m = c.getMethod("print", int.class, int.class);
    // Object o = m.invoke(a, new Object[]{10, 20});
    Object o = m.invoke(a, 10, 20);
} catch (Exception e) {
    e.printStackTrace();
}

Java 類載入機制

ArrayList list = new ArrayList();
ArrayList<String> list1 = new ArrayList<String>();
list == list1; // true
list1.add(20); // error - 編譯檢測出錯
  • 反射都是編譯之後的操作，因此可看出泛型在編譯之後會被擦除
  • Java 中集合的泛型用於防止錯誤輸入，只在編譯階段有效，繞過編譯則無效
Class c = list1.getclass();
try {
    Method m = c.getMethod("add", Object.class);
    m.invoke(list1, 20); // correct - 繞過編譯操作就繞過了泛型
} catch (Exception e) {
    e.printStackTrace();
}

參考資料：

相關文章