關於Java反射的理解

title: 關於Java反射的理解
date: 2017-12-07 14:34:21
tags: javaSE
categories: javaSE

首先，從動態語言講起。像Python、Ruby這種語言，只要修改了代碼，修改的效果立即生效，因爲這種語言是無需編譯，直接執行代碼的，我們稱這類語言是“動態語言”。而C++、Java這種，在運行之前需要先編譯，如果中途修改了代碼不重新編譯去執行的話就沒有變化。但是，Java有一個非常突出的動態相關機制，即反射：我們可以於運行時（區別於編譯時）加載、探知、使用編譯期間完全未知的classes。換句話說，Java程序可以加載一個運行時才得知名稱的class（在這之前修改這個類即時不編譯都有效），獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其methods。

再通俗地說一下什麼是反射？

普通的Java對象是通過new關鍵字把對應類的字節碼文件加載到內存，然後創建該對象的。

反射是通過一個名爲Class的特殊類，用Class.forName(“類名”);得到類的字節碼對象，然後用newInstance()方法在虛擬機內部構造這個對象（針對無參構造函數）。

也就是說反射機制讓我們可以在程序運行時動態地拿到Java類對應的字節碼對象（而不是在編譯的時候），然後動態的進行任何可能的操作。反射的功能主要包括：

在運行時判斷任意一個對象所屬的類
在運行時構造任意一個類的對象
在運行時判斷任意一個類所具有的成員變量和方法
在運行時調用任意一個對象的方法（這樣就可以修改這個對象的屬性）
生成動態代理

使用反射的主要作用是方便程序的擴展，由於其運行時動態加載的特性。

Class類

Java中只有2種東西不是面向對象的，一個基本類型，一個靜態成員（方法、變量、常量）。我們提供的每一個類也是對象，一個類的類類型是java.lang.Class類的實例對象。

// 創建類Foo的實例對象
Foo foo1 = new Foo();

// Foo這個類也是一個實例對象，Class類的實例對象
// 任何一個類都是Class的實例對象，這個實例對象有三種表達方式

// 第一種表達方式。實際上表明任何一個類都有一個隱含的靜態成員變量Class
Class c1 = Foo.class;

// 第二種表達方式
Class c2 = foo1.getClass();

// 根據官網說法，c1,c2表示了Foo類的類類型(class type)
// 類也是對象，是Class類的實例對象，這個對象我們成爲該類的類類型

System.out.println(c1==c2)   // true
 
// 第三種表達方式
Class c3 = Class.forName("Foo");
 
System.out.println(c1==c3)   // true

Class類的構造器是私有的，只能JVM能創建Class類的實例對象。

可以通過類類型 (上面的c1 c2 c3)創建Foo類的實例對象：

Foo foo = (Foo)c1.newInstance();

動態加載類

什麼是動態加載？什麼是靜態加載？

靜態加載的類在編譯的時候就要提供，而動態加載的類在源程序編譯時可以缺席。區分編譯時和運行時。

Class.forName(“類名”) 這種方式，不僅表示了類的類類型，還代表了動態加載類。

用new這種方式靜態加載方式，編譯的時候，如果new的對象的那個類不存在的話，編譯不通過；但是用Class.forName這種動態加載方式，沒有這個類編譯的時候不會報任何錯，但是運行的時候會因爲找不到這個類而報錯。動態加載有什麼好處呢？配合接口編程，可以實現一個接口對多種實現，從而可以動態地去選擇完成不同的功能。因此，類動態加載對擴展功能很有用。

其實，動態類加載主要就是通過反射機制將類對象注入進去。

靜態加載：

public class Office_Static {  
    public static void main(String[] args) {  
        //new 創建對象，是靜態加載類，在編譯時刻就需要用到Word和Excel，並將其編譯
        if("Word".equals(args[0])){  
            Word w = new Word();  
            w.start();  
        }  
        if("Excel".equals(args[0])){  
            Excel e = new Excel();  
            e.start();  
        }  
    }  
}

動態加載：

public interface OfficeAble {  
    public void start();  
}

public class Word implements OfficeAble {  
    public void start(){  
        System.out.println("word start");  
    }  
}

public class Excel implements OfficeAble {  
    public void start(){  
        System.out.println("excel start");  
    }  
}

public class OfficeBetter {  
    public static void main(String[] args) {  
        try {  
            //動態加載類，在運行時刻纔要用這個類  
            Class c = Class.forName(args[0]);//在運行配置裏面輸入com.imooc.加載類.Excel  
            //通過類類型，創建該類對象(先轉換爲Word和Excel的共同接口OfficeAble)  
            OfficeAble oa = (OfficeAble)c.newInstance();  
            oa.start();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
}

通過反射動態獲取對象的方法屬性構造器信息

import java.lang.reflect.Method;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;

public class ClassUtil {
    /**
     * 打印類的信息，包括類的成員函數、成員變量(只獲取成員函數)
     * 
     * @param obj
     *            該對象所屬類的信息
     */
    public static void printClassMethodMessage(Object obj) {
        // 要獲取類的信息 首先要獲取類的類類型
        Class c = obj.getClass();// 傳遞的是哪個子類的對象 c就是該子類的類類型
        // 獲取類的名稱
        System.out.println("類的名稱是:" + 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();
            System.out.print(returnType.getName() + " ");
            // 得到方法的名稱
            System.out.print(ms[i].getName() + "(");
            // 獲取參數類型--->得到的是參數列表的類型的類類型
            Class[] paramTypes = ms[i].getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }

    /**
     * 獲取成員變量的信息
     * 
     * @param obj
     */
    public static void printFieldMessage(Object obj) {
        Class c = obj.getClass();
        /*
         * 成員變量也是對象 java.lang.reflect.Field Field類封裝了關於成員變量的操作
         * getFields()方法獲取的是所有的public的成員變量的信息
         * getDeclaredFields獲取的是該類自己聲明的成員變量的信息
         */
        // Field[] fs = c.getFields();
        Field[] fs = c.getDeclaredFields();
        for (Field field : fs) {
            // 得到成員變量的類型的類類型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            // 得到成員變量的名稱
            String fieldName = field.getName();
            System.out.println(typeName + " " + fieldName);
        }
    }

    /**
     * 打印對象的構造函數的信息
     * 
     * @param obj
     */
    public static void printConMessage(Object obj) {
        Class c = obj.getClass();
        /*
         * 構造函數也是對象 java.lang. Constructor中封裝了構造函數的信息
         * getConstructors獲取所有的public的構造函數 getDeclaredConstructors得到所有的構造函數
         */
        // Constructor[] cs = c.getConstructors();
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName() + "(");
            // 獲取構造函數的參數列表--->得到的是參數列表的類類型
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }
}

通過反射運行時動態調用對象的方法

用方法對象進行反射操作，運行時動態調用一個對象的方法：

import java.lang.reflect.Method;

public class MethodDemo1 {
    public static void main(String[] args) {
        // 要獲取print(int ,int )方法 1.要獲取一個方法就是獲取類的信息，獲取類的信息首先要獲取類的類類型
        A a1 = new A();
        Class c = a1.getClass();
        /*
         * 2.獲取方法 名稱和參數列表來決定 getMethod獲取的是public的方法 getDelcaredMethod自己聲明的方法
         */
        try {
            // Method m = c.getMethod("print", new
            // Class[]{int.class,int.class});
            Method m = c.getMethod("print", int.class, int.class);

            // 方法的反射操作
            // a1.print(10, 20);方法的反射操作是用m對象來進行方法調用 和a1.print調用的效果完全相同
            // 方法如果沒有返回值返回null,有返回值返回具體的返回值
            // Object o = m.invoke(a1,new Object[]{10,20});
            Object o = m.invoke(a1, 10, 20);
            System.out.println("==================");
            // 獲取方法print(String,String)
            Method m1 = c.getMethod("print", String.class, String.class);
            // 用方法進行反射操作
            // a1.print("hello", "WORLD");
            o = m1.invoke(a1, "hello", "WORLD");
            System.out.println("===================");
            // Method m2 = c.getMethod("print", new Class[]{});
            Method m2 = c.getMethod("print");
            // m2.invoke(a1, new Object[]{});
            m2.invoke(a1);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

class A {
    public void print() {
        System.out.println("helloworld");
    }

    public void print(int a, int b) {
        System.out.println(a + b);
    }

    public void print(String a, String b) {
        System.out.println(a.toUpperCase() + "," + b.toLowerCase());
    }
}

通過反射了解Java泛型的本質

反射的操作都是編譯之後的操作，反射動態加載的類是在程序運行時編譯並加載的。來看看下面這個例子。

import java.lang.reflect.Method;
import java.util.ArrayList;

public class MethodDemo2{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        
        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("hello");
        //list1.add(20);錯誤的
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);// 都是ArrayList的類類型，true
        //反射的操作都是編譯之後的操作
        
        /*
         * c1==c2結果返回true說明編譯之後集合的泛型是去泛型化的
         * Java中集合的泛型，是防止錯誤輸入的，只在編譯階段有效，
         * 繞過編譯就無效了
         * 驗證：我們可以通過方法的反射來操作，繞過編譯
         */
        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(list1, 20);//繞過編譯操作就繞過了泛型
            System.out.println(list1.size());
            System.out.println(list1);
            /*for (String string : list1) {
                System.out.println(string);
            }*///現在不能這樣遍歷
        } catch (Exception e) {
          e.printStackTrace();
        }
    }

}

轉載自：http://lioncruise.github.io/2016/11/29/java-reflection/

關於Java反射的理解

title: 關於Java反射的理解
date: 2017-12-07 14:34:21
tags: javaSE
categories: javaSE

Class類

動態加載類

通過反射動態獲取對象的方法屬性構造器信息

通過反射運行時動態調用對象的方法

通過反射了解Java泛型的本質

RNN和LSTM理解結構圖

關於Java反射的理解

黑客帝國全解析

繼承與多態的區別

理解Java中的弱引用

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

關於Java反射的理解

title: 關於Java反射的理解 date: 2017-12-07 14:34:21 tags: javaSE categories: javaSE

Class類

動態加載類

通過反射動態獲取對象的方法屬性構造器信息

通過反射運行時動態調用對象的方法

通過反射了解Java泛型的本質

title: 關於Java反射的理解
date: 2017-12-07 14:34:21
tags: javaSE
categories: javaSE