一、概念
?? ? ? 主要是指程序可以訪問，檢測和修改它本身狀態或行為的一種能力，并能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。在java中，只要給定類的名字， 那么就可以通過反射機制來獲得類的所有信息。
? ? ? ?反射是Java中一種強大的工具，能夠使我們很方便的創建靈活的代碼，這些代碼可以再運行時裝配，無需在組件之間進行源代碼鏈接。但是反射使用不當會成本很高！
? ? ? ?類中有什么信息，利用反射機制就能可以獲得什么信息，不過前提是得知道類的名字。
二、作用
? ? 1）在運行時判斷任意一個對象所屬的類；
? ? 2）在運行時獲取類的對象；
? ? 3）在運行時訪問java對象的屬性，方法，構造方法等。
三、優點與缺點
? ? ? ?首先要搞清楚為什么要用反射機制？直接創建對象不就可以了嗎，這就涉及到了動態與靜態的概念。?
? ? ? ?靜態編譯：在編譯時確定類型，綁定對象，即通過。?
? ? ? ?動態編譯：運行時確定類型，綁定對象。動態編譯最大限度發揮了java的靈活性，體現了多態的應用，有以降低類之間的藕合性。
? ? ? ?反射機制的優點：可以實現動態創建對象和編譯，體現出很大的靈活性（特別是在J2EE的開發中它的靈活性就表現的十分明顯）。通過反射機制我們可以獲得類的各種內容，進行了反編譯。對于JAVA這種先編譯再運行的語言來說，反射機制可以使代碼更加靈活，更加容易實現面向對象。
? ? ? ?比如，一個大型的軟件，不可能一次就把把它設計的很完美，當這個程序編譯后，發布了，當發現需要更新某些功能時，我們不可能要用戶把以前的卸載，再重新安裝新的版本，假如這樣的話，這個軟件肯定是沒有多少人用的。采用靜態的話，需要把整個程序重新編譯一次才可以實現功能的更新，而采用反射機制的話，它就可以不用卸載，只需要在運行時才動態的創建和編譯，就可以實現該功能。?
? ? ? ?反射機制的缺點：對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什么并且它 滿足我們的要求。這類操作總是慢于只直接執行相同的操作。
四、示例
1、通過一個對象獲取完整的包名和類名
注：所有類的對象其實都是Class類的實例
package Reflect;class Demo{//other codes...
}class hello{public static void main(String[] args) {Demo demo=new Demo();System.out.println(demo.getClass().getName());}
}
Reflect.Demopackage Reflect;class Demo{//other codes...
}class hello{public static void main(String[] args) {Class<?> demo1=null;Class<?> demo2=null;Class<?> demo3=null;try{//一般盡量采用這種形式demo1=Class.forName("Reflect.Demo");}catch(Exception e){e.printStackTrace();}demo2=new Demo().getClass();demo3=Demo.class;System.out.println("類名稱 "+demo1.getName());System.out.println("類名稱 "+demo2.getName());System.out.println("類名稱 "+demo3.getName());}
}
類名稱 Reflect.Demo
類名稱 Reflect.Demo
類名稱 Reflect.Demopackage Reflect;class Person{public 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;}@Overridepublic String toString(){return "["+this.name+" "+this.age+"]";}private String name;private int age;
}class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Person per=null;try {per=(Person)demo.newInstance();} catch (InstantiationException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalAccessException e) {// TODO Auto-generated catch blocke.printStackTrace();}per.setName("Rollen");per.setAge(20);System.out.println(per);}
}
[Rollen 20]? ? ? ?但是注意一下，當我們把Person中的默認的無參構造函數取消的時候，比如自己定義只定義一個有參數的構造函數之后，會出現錯誤：
比如定義了一個構造函數：
public Person(String name, int age) { this.age=age;this.name=name;
}java.lang.InstantiationException: Reflect.Person
at java.lang.Class.newInstance0(Class.java:340)
at java.lang.Class.newInstance(Class.java:308)
at Reflect.hello.main(hello.java:39)
Exception in thread "main" java.lang.NullPointerException
at Reflect.hello.main(hello.java:47)4、通過Class調用其他類中的構造函數 （也可以通過這種方式通過Class創建其他類的對象）
package Reflect;import java.lang.reflect.Constructor;class Person{public Person() { }public Person(String name){this.name=name;}public Person(int age){this.age=age;}public Person(String name, int age) {this.age=age;this.name=name;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString(){return "["+this.name+" "+this.age+"]";}private String name;private int age;
}class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Person per1=null;Person per2=null;Person per3=null;Person per4=null;//取得全部的構造函數Constructor<?> cons[]=demo.getConstructors();try{per1=(Person)cons[0].newInstance();per2=(Person)cons[1].newInstance("Rollen");per3=(Person)cons[2].newInstance(20);per4=(Person)cons[3].newInstance("Rollen",20);}catch(Exception e){e.printStackTrace();}System.out.println(per1);System.out.println(per2);System.out.println(per3);System.out.println(per4);}
}
[null 0]
[Rollen 0]
[null 20]
[Rollen 20]package Reflect;interface China{public static final String name="Rollen";public static int age=20;public void sayChina();public void sayHello(String name, int age);
}class Person implements China{public Person() {}public Person(String sex){this.sex=sex;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic void sayChina(){System.out.println("hello ,china");}@Overridepublic void sayHello(String name, int age){System.out.println(name+" "+age);}private String sex;
}class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}//保存所有的接口Class<?> intes[]=demo.getInterfaces();for (int i = 0; i < intes.length; i++) {System.out.println("實現的接口 "+intes[i].getName());}}
}
實現的接口 Reflect.China6、取得其他類中的父類
class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}//取得父類Class<?> temp=demo.getSuperclass();System.out.println("繼承的父類為： "+temp.getName());}
}
繼承的父類為： java.lang.Object//這個例子需要在程序開頭添加import java.lang.reflect.*;
class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Constructor<?>cons[]=demo.getConstructors();for (int i = 0; i < cons.length; i++) {System.out.println("構造方法： "+cons[i]);}}
}
構造方法： public Reflect.Person()
構造方法： public Reflect.Person(java.lang.String)class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Constructor<?>cons[]=demo.getConstructors();for (int i = 0; i < cons.length; i++) {Class<?> p[]=cons[i].getParameterTypes();System.out.print("構造方法： ");int mo=cons[i].getModifiers();System.out.print(Modifier.toString(mo)+" ");System.out.print(cons[i].getName());System.out.print("(");for(int j=0;j<p.length;++j){System.out.print(p[j].getName()+" arg"+i);if(j<p.length-1){System.out.print(",");}}System.out.println("){}");}}
}
構造方法： public Reflect.Person(){}
構造方法： public Reflect.Person(java.lang.String arg1){}8、取得其他類的全部屬性，將這些整理在一起，也就是通過class取得一個類的全部框架
class hello {public static void main(String[] args) {Class<?> demo = null;try {demo = Class.forName("Reflect.Person");} catch (Exception e) {e.printStackTrace();}System.out.println("===============本類屬性========================");// 取得本類的全部屬性Field[] field = demo.getDeclaredFields();for (int i = 0; i < field.length; i++) {// 權限修飾符int mo = field[i].getModifiers();String priv = Modifier.toString(mo);// 屬性類型Class<?> type = field[i].getType();System.out.println(priv + " " + type.getName() + " "+ field[i].getName() + ";");}System.out.println("===============實現的接口或者父類的屬性========================");// 取得實現的接口或者父類的屬性Field[] filed1 = demo.getFields();for (int j = 0; j < filed1.length; j++) {// 權限修飾符int mo = filed1[j].getModifiers();String priv = Modifier.toString(mo);// 屬性類型Class<?> type = filed1[j].getType();System.out.println(priv + " " + type.getName() + " "+ filed1[j].getName() + ";");}}
}
===============本類屬性========================
private java.lang.String sex;
===============實現的接口或者父類的屬性========================
public static final java.lang.String name;
public static final int age;class hello {public static void main(String[] args) {Class<?> demo = null;try {demo = Class.forName("Reflect.Person");} catch (Exception e) {e.printStackTrace();}try{//調用Person類中的sayChina方法Method method=demo.getMethod("sayChina");method.invoke(demo.newInstance());//調用Person的sayHello方法method=demo.getMethod("sayHello", String.class,int.class);method.invoke(demo.newInstance(),"Rollen",20);}catch (Exception e) {e.printStackTrace();}}
}
hello ,china
Rollen 2010、調用其他類的set和get方法
class hello {public static void main(String[] args) {Class<?> demo = null;Object obj=null;try {demo = Class.forName("Reflect.Person");} catch (Exception e) {e.printStackTrace();}try{obj=demo.newInstance();}catch (Exception e) {e.printStackTrace();}setter(obj,"Sex","男",String.class);getter(obj,"Sex");}/*** @param obj 操作的對象* @param att 操作的屬性* */public static void getter(Object obj, String att) {try {Method method = obj.getClass().getMethod("get" + att);System.out.println(method.invoke(obj));} catch (Exception e) {e.printStackTrace();}}/*** @param obj 操作的對象 * @param att 操作的屬性* @param value 設置的值* @param type 參數的屬性* */public static void setter(Object obj, String att, Object value,Class<?> type) {try {Method method = obj.getClass().getMethod("set" + att, type);method.invoke(obj, value);} catch (Exception e) {e.printStackTrace();}}
}// end class
男class hello {public static void main(String[] args) throws Exception {Class<?> demo = null;Object obj = null;demo = Class.forName("Reflect.Person");obj = demo.newInstance();Field field = demo.getDeclaredField("sex");field.setAccessible(true);field.set(obj, "男");System.out.println(field.get(obj));}
}// end classimport java.lang.reflect.*;class hello{public static void main(String[] args) {int[] temp={1,2,3,4,5};Class<?>demo=temp.getClass().getComponentType();System.out.println("數組類型： "+demo.getName());System.out.println("數組長度 "+Array.getLength(temp));System.out.println("數組的第一個元素: "+Array.get(temp, 0));Array.set(temp, 0, 100);System.out.println("修改之后數組第一個元素為： "+Array.get(temp, 0));}
}
數組類型： int
數組長度 5
數組的第一個元素: 1
修改之后數組第一個元素為： 100class hello{public static void main(String[] args) {int[] temp={1,2,3,4,5,6,7,8,9};int[] newTemp=(int[])arrayInc(temp,15);print(newTemp);System.out.println("=====================");String[] atr={"a","b","c"};String[] str1=(String[])arrayInc(atr,8);print(str1);}/*** 修改數組大小* */public 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;}/*** 打印* */public static void print(Object obj){Class<?>c=obj.getClass();if(!c.isArray()){return;}System.out.println("數組長度為： "+Array.getLength(obj));for (int i = 0; i < Array.getLength(obj); i++) {System.out.print(Array.get(obj, i)+" ");}}
}
數組長度為： 15
1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================
數組長度為： 8
a b c null null null null null首先來看看如何獲得類加載器：
class test{}
class hello{public static void main(String[] args) {test t=new test();System.out.println("類加載器 "+t.getClass().getClassLoader().getClass().getName());}
}
類加載器 sun.misc.Launcher$AppClassLoader其實在java中有三種類類加載器：
? ? 1）Bootstrap ClassLoader 此加載器采用c++編寫，一般開發中很少見。
? ? 2）Extension ClassLoader 用來進行擴展類的加載，一般對應的是jre\lib\ext目錄中的類
? ? 3）AppClassLoader 加載classpath指定的類，是最常用的加載器。同時也是java中默認的加載器。
如果想要完成動態代理，首先需要定義一個InvocationHandler接口的子類，已完成代理的具體操作。
package Reflect;import java.lang.reflect.*;//定義項目接口
interface Subject {public String say(String name, int age);
}// 定義真實項目
class RealSubject implements Subject {@Overridepublic String say(String name, int age) {return name + " " + age;}
}class MyInvocationHandler implements InvocationHandler {private Object obj = null;public Object bind(Object obj) {this.obj = obj;return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {Object temp = method.invoke(this.obj, args);return temp;}
}class hello {public static void main(String[] args) {MyInvocationHandler demo = new MyInvocationHandler();Subject sub = (Subject) demo.bind(new RealSubject());String info = sub.say("Rollen", 20);System.out.println(info);}
}
Rollen 20類的生命周期
? ? ? ?在一個類編譯完成之后，下一步就需要開始使用類，如果要使用一個類，肯定離不開JVM。在程序執行中JVM通過裝載、鏈接、初始化這3個步驟完成。
? ? ? ?類的裝載是通過類加載器完成的，加載器將.class文件的二進制文件裝入JVM的方法區，并且在堆區創建描述這個類的java.lang.Class對象。用來封裝數據。 但是同一個類只會被類裝載器裝載一次。
鏈接就是把二進制數據組裝為可以運行的狀態。
鏈接分為校驗，準備，解析這3個階段：
? ? 校驗：一般用來確認此二進制文件是否適合當前的JVM（版本），
? ? 準備：就是為靜態成員分配內存空間，。并設置默認值
? ? 解析：指的是轉換常量池中的代碼作為直接引用的過程，直到所有的符號引用都可以被運行程序使用（建立完整的對應關系）。
? ? ? ?完成之后，類型也就完成了初始化，初始化之后類的對象就可以正常使用了，直到一個對象不再使用之后，將被垃圾回收。釋放空間。當沒有任何引用指向Class對象時就會被卸載，結束類的生命周期。
Spring中的IoC的實現原理就是工廠模式加反射機制。
1、我們首先看一下不用反射機制時的工廠模式
/*** 工廠模式*/
interface fruit{public abstract void eat();
}class Apple implements fruit{public void eat(){System.out.println("Apple");}
}class Orange implements fruit{public void eat(){System.out.println("Orange");}
}
// 構造工廠類
// 也就是說以后如果我們在添加其他的實例的時候只需要修改工廠類就行了
class Factory{public static fruit getInstance(String fruitName){fruit f=null;if("Apple".equals(fruitName)){f=new Apple();}if("Orange".equals(fruitName)){f=new Orange();}return f;}
}class hello{public static void main(String[] a){fruit f=Factory.getInstance("Orange");f.eat();}
}2、利用反射機制的工廠模式
package Reflect;interface fruit{public abstract void eat();
}class Apple implements fruit{public void eat(){System.out.println("Apple");}
}class Orange implements fruit{public void eat(){System.out.println("Orange");}
}class Factory{public static fruit getInstance(String ClassName){fruit f=null;try{f=(fruit)Class.forName(ClassName).newInstance();}catch (Exception e) {e.printStackTrace();}return f;}
}class hello{public static void main(String[] a){fruit f=Factory.getInstance("Reflect.Apple");if(f!=null){f.eat();}}
}? ? ? ?現在就算我們添加任意多個子類的時候，工廠類就不需要修改。
? ? ? ?使用反射機制的工廠模式可以通過反射取得接口的實例，但是需要傳入完整的包和類名。而且用戶也無法知道一個接口有多少個可以使用的子類，所以我們通過屬性文件的形式配置所需要的子類。
3、使用反射機制并結合屬性文件的工廠模式（即IoC）首先創建一個fruit.properties的資源文件：
apple=Reflect.Apple
orange=Reflect.Orangepackage Reflect;import java.io.*;
import java.util.*;interface fruit{public abstract void eat();
}class Apple implements fruit{public void eat(){System.out.println("Apple");}
}class Orange implements fruit{public void eat(){System.out.println("Orange");}
}
//操作屬性文件類
class init{public static Properties getPro() throws FileNotFoundException, IOException{Properties pro=new Properties();File f=new File("fruit.properties");if(f.exists()){pro.load(new FileInputStream(f));}else{pro.setProperty("apple", "Reflect.Apple");pro.setProperty("orange", "Reflect.Orange");pro.store(new FileOutputStream(f), "FRUIT CLASS");}return pro;}
}class Factory{public static fruit getInstance(String ClassName){fruit f=null;try{f=(fruit)Class.forName(ClassName).newInstance();}catch (Exception e) {e.printStackTrace();}return f;}
}class hello{public static void main(String[] a) throws FileNotFoundException, IOException{Properties pro=init.getPro();fruit f=Factory.getInstance(pro.getProperty("apple"));if(f!=null){f.eat();}}
}
Apple
