Java---類反射(1)---類反射入門和基礎
什么是類反射
☆什么是反射
JAVA反射機制是在運行狀態中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為Java語言的反射機制。
反射(Reflection)是Java程序開發語言的特征之一，它允許運行中的Java程序對自身進行檢查， 也稱自審，并能直接操作程序的內部屬性。例如，使用它能獲得Java類中各成員的名稱并顯示出來。
Java的這一能力在實際應用中應用得很多，在其它的程序語言中根本就不存在這一特性。例如，Pascal、C或者C++中就沒有辦法在程序中獲得函數定義相關的信息。
JavaBean是類反射的實際應用之一，它能讓一些工具可視化的操作軟件組件。這些工具通過類反射動態的載入并取得Java組件(類)的屬性。后面學習的各種框架，基本上都會有反射的使用。
☆反射引例(HelloWorld、USB)
最簡單的類反射：(相當于HelloWorld)
package cn.hncu.hello; import java.lang.reflect.Method; import java.lang.reflect.Modifier; /** * 類反射的Helloworld版---入門 * 只演示了類方法的類反射---Method[] * @author 陳浩翔 * @version 1.0 2016-5-1 */ public class ReflectionHelloWold { public static void main(String[] args) { try { Class c = Class.forName("cn.hncu.introduce.Person"); System.out.println(c); Method mc[] = c.getDeclaredMethods();//獲得 for(Method m:mc){ //獲得整個方法 //包括修飾，返回類型，方法名字，方法參數 System.out.println(m); //解剖Method對象 System.out.println(Modifier.toString(m.getModifiers()));//修飾符 System.out.println(m.getReturnType());//返回類型 System.out.println(m.getName());//方法名字 Class pt[] = m.getParameterTypes(); for(Class p :pt){ System.out.println("parameter = "+p);//參數 } System.out.println(); System.out.println(m.getDeclaringClass());//這個方法所在的類 System.out.println(); System.out.println("------------------------------"); } } catch (ClassNotFoundException e) { e.printStackTrace(); } } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Person類：
package cn.hncu.introduce; public class Person { private String name; int age; public final String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } private static final int sum(int age){ return 0; } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
輸出結果：
class cn.hncu.introduce.Person private static final int cn.hncu.introduce.Person.sum(int) private static final int sum parameter = int class cn.hncu.introduce.Person ------------------------------ public int cn.hncu.introduce.Person.getAge() public int getAge class cn.hncu.introduce.Person ------------------------------ public void cn.hncu.introduce.Person.setAge(int) public void setAge parameter = int class cn.hncu.introduce.Person ------------------------------ public final java.lang.String cn.hncu.introduce.Person.getName() public final class java.lang.String getName class cn.hncu.introduce.Person ------------------------------ public void cn.hncu.introduce.Person.setName(java.lang.String) public void setName parameter = class java.lang.String class cn.hncu.introduce.Person ------------------------------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
USB實例：反射最大的好處是解耦
USB接口：
package cn.hncu.usb.api; public interface USB { public abstract void work(); }
1
2
3
4
5
6
實現類：
package cn.hncu.usb.impl; import cn.hncu.usb.api.USB; public class UsbMouse implements USB{ @Override public void work() { System.out.println("UsbMouse...."); } }
1
2
3
4
5
6
7
8
9
10
11
package cn.hncu.usb.impl; import cn.hncu.usb.api.USB; public class UsbOne implements USB{ @Override public void work() { System.out.println("UsbOne..."); } }
1
2
3
4
5
6
7
8
9
10
11
package cn.hncu.usb.impl; import cn.hncu.usb.api.USB; public class UsbTwo implements USB{ @Override public void work() { System.out.println("UsbTwo...."); } }
1
2
3
4
5
6
7
8
9
10
11
工廠方法：！！！讀取配置文件的在這里
package cn.hncu.usb.factory; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Properties; import cn.hncu.usb.api.USB; public class USBFactory { public static USB getUSB(){ USB usb = null; Properties p = new Properties();//配置文件 FileInputStream in; try { in = new FileInputStream("usb.config");//讀取配置文件 p.load(in); String className = p.getProperty("name"); //通過name獲得name后面=號后面的字符串，這樣就可以通過修改配置文件來new不同的類 Class c = Class.forName(className); usb = (USB) c.newInstance();//new 一個對象 } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } return usb; } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
main方法：
package cn.hncu.usb; import cn.hncu.usb.api.USB; import cn.hncu.usb.factory.USBFactory; public class Client { public static void main(String[] args) { USB usb = USBFactory.getUSB(); usb.work(); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
配置文件：usb.config
你配置哪個，就是new哪個實現類的！！
‘#’號是配置文件的注釋
#name = cn.hncu.usb.impl.UsbOne #name = cn.hncu.usb.impl.UsbTwo name = cn.hncu.usb.impl.UsbMouse
1
2
3
反射使用的三個步驟
用于反射的類，如Method，可以在java.lang.reflect包中找到。使用這些類的時候必須要遵循三個步驟：
第一步：獲得你想操作的類的java.lang.Class對象。在運行中的Java程序中，用java.lang.Class類來描述類和接口等。
第二步：調用諸如getDeclaredMethods的方法，取得該類中定義的所有方法的列表。
第三步：使用反射的API來操作這些信息。
如下面這段代碼：
Class c = Class.forName(“java.lang.String”);
Method ms[] = c.getDeclaredMethods();
System.out.println(ms[0].toString());
它將以文本方式打印出String中定義的第一個方法的原型。
☆反射示例(模擬instanceof的功能)
獲取Class對象的三種方式
★ 方式一
通過對象的getClass方法進行獲取。這種方式需要具體的類和該類的對象，以及調用getClass方法。
★ 方式二
任何數據類型(包括基本數據類型)都具備著一個靜態的屬性class，通過它可直接獲取到該類型對應的Class對象。這種方式要使用具體的類，然后調用類中的靜態屬性class完成，無需調用方法，性能更好。
★ 方式三
通過Class.forName()方法獲取。這種方式僅需使用類名，就可以獲取該類的Class對象，更有利于擴展。
下面看怎么獲取Class對象的代碼：
package cn.hncu.reflect; /** * //獲取Class對象的三種方式 * @author 陳浩翔 * * @version 1.0 2016-5-1 */ public class ReflectGetClass { public static void main(String[] args) { //getClassObj1(); //getClassObj2(); //getClassObj3(); test(); } private static void test() { Person p = new Person(); Object obj = (Object)p; Class c = obj.getClass();//運行時多態，new誰調誰 System.out.println(c);//輸出為：class cn.hncu.reflect.Person System.out.println(int.class);//int System.out.println(Integer.class);//class java.lang.Integer System.out.println(Integer.TYPE);//int System.out.println((int.class)==(Integer.class));//false System.out.println((int.class)==(Integer.TYPE));//true } private static void getClassObj3() { try { String className = "cn.hncu.reflect.Person"; Class c = Class.forName(className);//3333用字符串(類名)---依賴于String類 System.out.println(c);//class cn.hncu.reflect.Person } catch (ClassNotFoundException e) { e.printStackTrace(); } } private static void getClassObj2() { Class c = Person.class;//2222通過類名----依賴于Person類 System.out.println(c);//class cn.hncu.reflect.Person } private static void getClassObj1() { Person p1 = new Person(); Class c1 = p1.getClass();//1111通過對象 System.out.println(c1);//class cn.hncu.reflect.Person Person p2 = new Person(); Class c2 = p2.getClass(); System.out.println(p1==p2);//false-不同的對象 System.out.println(c1==c2);//true-同一個類模板，所有對象是共享同一個類模板的 } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
運行結果在輸出后面都注釋了。。。
Class.isInstance(Object obj)判定指定的 Object 是否與此 Class 所表示的對象賦值兼容。
代碼演示：
package cn.hncu.reflect; /** * @author 陳浩翔 * @version 1.0 2016-5-1 */ public class SimulateInstanceof { /** * isInstance(Object obj)判定指定的 Object 是否與此 Class 所表示的對象賦值兼容。 * @param args * @throws Exception */ public static void main(String[] args) throws Exception { Class c = Class.forName("cn.hncu.reflect.A"); boolean boo = c.isInstance(new Integer(100)); System.out.println(boo);//false boolean boo2 = c.isInstance( new A() ); System.out.println(boo2);//true boolean boo3 = c.isInstance(new B());//B和A兼容 //也就是說子類可以當父類用 System.out.println(boo3);//true } } class A{ private int age; } class B extends A{ private String name ; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
類的解剖（獲取類的定義信息）
Person類：
package cn.hncu.reflect; import java.io.IOException; public class Person extends Parent{ String name; private int age; public int num; public static String schoolName; public Person(){ } private Person(String name, int age){ } protected Person(int age) throws IOException,NumberFormatException{ } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } protected void setAge(int age) { this.age = age; } private int sum( int a){ return 0; } private int sum(){ return 0; } int aa(String a,int b) throws IOException,NumberFormatException{ return 0; } } class Parent{ public static final int N=100; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
★ 獲取類的方法
找出一個類中定義了些什么方法，這是一個非常有價值也非常基礎的反射用法。
代碼演示：
package cn.hncu.reflect; import java.lang.reflect.Method; import java.lang.reflect.Modifier; /** * 類的解剖（獲取類的定義信息） * @author 陳浩翔 * * @version 1.0 2016-5-1 */ public class ReflectDecompose { private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person"; public static void main(String[] args) { try { fetchMethods(CLASS_FILE_NAME);//方法演示 } catch (ClassNotFoundException e) { e.printStackTrace(); } } /** * 方法演示 * @param classFileName * @throws ClassNotFoundException */ private static void fetchMethods(String classFileName) throws ClassNotFoundException { Class c = Class.forName(CLASS_FILE_NAME); //1: 獲取該類的能訪問的所有public方法(包含當前類和父類的) Method methods[] = c.getMethods(); //2: 獲取Person類中聲明的所有方法，包括私有和其它權限的 //Method methods[] = c.getDeclaredMethods(); for(int i=0;i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 運行結果太長了，自己可以運行看看！ ★ 獲取類的構造器 找出一個類中定義的構造方法，構造器沒有返回類型。 代碼演示： package cn.hncu.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.lang.reflect.Modifier; /** * 類的解剖（獲取類的定義信息） * @author 陳浩翔 * * @version 1.0 2016-5-1 */ public class ReflectDecompose { private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person"; public static void main(String[] args) { try { //fetchMethods(CLASS_FILE_NAME);//方法演示 fetchConstructors(CLASS_FILE_NAME);//類的構造方法演示 } catch (ClassNotFoundException e) { e.printStackTrace(); } } /** * 類的構造方法演示 * @param classFileName * @throws ClassNotFoundException */ private static void fetchConstructors(String classFileName) throws ClassNotFoundException { Class c = Class.forName(CLASS_FILE_NAME); //構造方法不能繼承父類的！！！！！！！ //1: 該類中所有public的構造方法。 Constructor cons[] = c.getConstructors(); //2: 獲取該類中聲明的所有構造方法，包括私有和其它權限的 //Constructor cons[] = c.getDeclaredConstructors(); for(int i=0;i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 ★ 獲取類的屬性字段 找出一個類中定義了哪些屬性字段。 代碼演示： package cn.hncu.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; /** * 類的解剖（獲取類的定義信息） * @author 陳浩翔 * * @version 1.0 2016-5-1 */ public class ReflectDecompose { private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person"; public static void main(String[] args) { try { //fetchMethods(CLASS_FILE_NAME);//方法演示 //fetchConstructors(CLASS_FILE_NAME);//類的構造方法演示 fetchFields(CLASS_FILE_NAME);//類的成員變量演示 } catch (ClassNotFoundException e) { e.printStackTrace(); } } /** * 類的成員變量演示 * @param classFileName * @throws ClassNotFoundException */ private static void fetchFields(String classFileName) throws ClassNotFoundException { Class c = Class.forName(CLASS_FILE_NAME); //獲取該類及其父類中的所有public成員變量(屬性) Field fields[] = c.getFields(); //獲取該類聲明的所有成員變量，包括私有及其它權限的 //Field fields[] = c.getDeclaredFields(); for(int i=0;i 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 Class類真的很強大！ Java
版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。
版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。
相關文章
