Java反射：Web學習的靈魂
反射：Web學習的靈魂
咱們從最初的 javac -HelloWorld.java，到面向對象部分，咱們能夠將Java代碼在計算機中經歷的階段分爲三部分： Scource源代碼階段 —— Class類對象階段 —— Runtime運行時階段 而咱們知道，Java中一個類在源代碼階段，是存儲在硬盤中的，而編譯後，就已經被加載到內存中區，那麼有沒有一種方法能夠在這種狀況下，獲取或者修改它的方法或者屬性呢？這就是咱們今天所講的 Java反射機制
(一) 概述以及好處
(1) 概述
JAVA反射機制是在 運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；對於任意一個對象，都可以調用它的任意一個方法和屬性；這種 動態獲取的信息以及 動態調用對象的方法的功能稱爲 java語言的反射機制。——百度百科
咱們將類分爲三部分，成員變量，構造方法，成員方法，代碼編譯後，變成了字節碼文件（.class文件）而萬物皆對象，因此在字節碼文件中，又將這三部分分別整合成對象，因此咱們得出結論：java
反射：將類的各個組成部分封裝成對象，並經過這個Class類型的對象，去使用該文件中的成員變量，構造方法，成員方法安全
(2) 好處
- 能夠在程序「運行時」，對 .class文件進行操做，而且由此獲取以及操做 類中的各個部分
- 能夠解耦，提升程序的擴展性
- 增長程序的靈活性 （最後案例中體現）
(二) 獲取Class對象的方式
（1）將字節碼文件加載進內存，返回Class對象
多用於配置文件，將類名定義在配置文件中。讀取文件，加載類dom
Class.forName("全類名")
（2）多用於參數的傳遞ide
類名.class
（3）getClass()方法在Object類中定義着
多用於對象的獲取字節碼的方式學習
對象.getClass()：
三種方式的代碼實現idea
package cn.ideal.reflect;
import cn.ideal.domain.Student;
public class ReflectDemo1 {
public static void main(String[] args) throws Exception {
//1.Class.forName("全類名")
Class cls1 = Class.forName("cn.ideal.domain.Student");
System.out.println(cls1);
//2.類名.class
Class cls2 = Student.class;
System.out.println(cls2);
//3.對象.getClass()
Student p = new Student();
Class cls3 = p.getClass();
System.out.println(cls3);
//用 == 比較
System.out.println(cls1 == cls2);//true
System.out.println(cls2 == cls3);//true
}
}
//運行結果
class cn.ideal.domain.Student
class cn.ideal.domain.Student
class cn.ideal.domain.Student
true
true
經過上面的案例咱們能夠得出：spa
同一個字節碼文件(*.class)在一次程序運行過程當中，只加載一次，不論經過哪種方式獲取的Class對象都是同一個code
(三) Class對象功能
(1) 獲取功能：
獲取成員變量們對象
//獲取全部public修飾的成員變量 Field[] getFields() //獲取指定名稱的public修飾的成員變量 Field getField(String name) //獲取全部的成員變量，不考慮修飾符 Field[] getDeclaredFields() Field getDeclaredField(String name)
構造方法們內存
Constructor<?>[] getConstructors() Constructor<T> getConstructor(類<?>... parameterTypes) Constructor<T> getDeclaredConstructor(類<?>... parameterTypes) Constructor<?>[] getDeclaredConstructors()
獲取成員方法們
Method[] getMethods() Method getMethod(String name, 類<?>... parameterTypes) Method[] getDeclaredMethods() Method getDeclaredMethod(String name, 類<?>... parameterTypes)
獲取全類名
String getName()
Field：成員變量
操做： //設置值 void set(Object obj, Object value) //獲取值 get(Object obj) //忽略訪問權限修飾符的安全檢查 setAccessible(true):暴力反射
Constructor:構造方法
建立對象： T newInstance(Object... initargs) 若是使用空參數構造方法建立對象，操做能夠簡化：Class對象的newInstance方法
Method：方法對象
//執行方法 Object invoke(Object obj, Object... args) //獲取方法名稱 String getName:獲取方法名
咱們來具體使用一下上面的一些方法
package cn.ideal.reflect;
import cn.ideal.domain.Student;
import java.lang.reflect.Field;
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
//獲取Student的Class對象
Class studentClass = Student.class;
/*
1. 獲取成員變量們
* Field[] getFields()
* Field getField(String name)
* Field[] getDeclaredFields()
Field getDeclaredField(String name)
*/
//Field[] getFields() 獲取全部public修飾的成員變量
Field[] fields = studentClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("----------");
//Field getField(String name)
Field a = studentClass.getField("a");
//獲取成員變量a的值
Student s = new Student();
Object value = a.get(s);
System.out.println(value);
//設置a的值
a.set(s, "張三");
System.out.println(s);
System.out.println("----------");
//Field[] getDeclaredFields() 獲取全部的成員變量
Field[] declaredFields = studentClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
System.out.println("----------");
//Field getDeclaredField(String name)
Field d = studentClass.getDeclaredField("d");
//忽略訪問權限修飾符
d.setAccessible(true);//暴力反射
Object value2 = d.get(s);
System.out.println(value2);
}
}
//運行結果
public java.lang.String cn.ideal.domain.Student.a
----------
null
Student{name='null', age=0, a='張三', b='null', c='null', d='null'}
----------
private java.lang.String cn.ideal.domain.Student.name
private int cn.ideal.domain.Student.age
public java.lang.String cn.ideal.domain.Student.a
protected java.lang.String cn.ideal.domain.Student.b
java.lang.String cn.ideal.domain.Student.c
private java.lang.String cn.ideal.domain.Student.d
----------
null
package cn.ideal.reflect;
import cn.ideal.domain.Student;
import java.lang.reflect.Constructor;
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
//獲取Student的Class對象
Class studentClass = Student.class;
/*
2. 獲取構造方法們
* Constructor<?>[] getConstructors()
* Constructor<T> getConstructor(類<?>... parameterTypes)
* Constructor<T> getDeclaredConstructor(類<?>... parameterTypes)
* Constructor<?>[] getDeclaredConstructors()
*/
//Constructor<T> getConstructor(類<?>... parameterTypes)
Constructor constructor = studentClass.getConstructor(String.class, int.class);
System.out.println(constructor);
//建立對象 帶參
Object student = constructor.newInstance("張三", 20);
System.out.println(student);
System.out.println("----------");
Constructor constructor1 = studentClass.getConstructor();
System.out.println(constructor1);
//建立對象 不帶參
Object student1 = constructor1.newInstance();
System.out.println(student1);
//建立對象 不帶參 （推薦方法）
Object o = studentClass.newInstance();
System.out.println(o);
}
}
package cn.ideal.reflect;
import cn.ideal.domain.Student;
import java.lang.reflect.Method;
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
//獲取Student的Class對象
Class studentClass = Student.class;
/*
3. 獲取成員方法們：
* Method[] getMethods()
* Method getMethod(String name, 類<?>... parameterTypes)
* Method[] getDeclaredMethods()
* Method getDeclaredMethod(String name, 類<?>... parameterTypes)
*/
//獲取指定名稱的方法
Method study_method = studentClass.getMethod("study");
Student s = new Student();
//執行方法
study_method.invoke(s);
Method study_method2 = studentClass.getMethod("study", String.class);
//執行方法
study_method2.invoke(s, "英語");
System.out.println("----------");
//獲取全部public修飾的方法
Method[] methods = studentClass.getMethods();
for (Method method : methods) {
System.out.println(method);
String name = method.getName();
System.out.println(name);
}
//獲取類名
String className = studentClass.getName();
System.out.println(className);
}
}
(四) 反射案例
經過修改配置文件，達到不改變該類的任何代碼，能夠建立任意類的對象，能夠執行任意方法，避免了每一次都修改類文件的缺點，同時提升了程序的擴展性
* 實現：
1. 配置文件
2. 反射
* 步驟：
1. 將須要建立的對象的全類名和須要執行的方法定義在配置文件中
2. 在程序中加載讀取配置文件
3. 使用反射技術來加載類文件進內存
4. 建立對象
5. 執行方法
//pro.properties 自定義配置文件 className=cn.ideal.domain.Student methodName=study
package cn.ideal.reflect;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
public class ReflectTest {
public static void main(String[] args) throws Exception {
/*
不改變該類的任何代碼，能夠建立任意類的對象，能夠執行任意方法
*/
//1.加載配置文件
//建立Properties對象
Properties pro = new Properties();
//加載配置文件，轉換爲一個集合
//獲取class目錄下的配置文件
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
pro.load(is);
//2.獲取配置文件中定義的數據
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加載該類進內存
Class cls = Class.forName(className);
//4.建立對象
Object obj = cls.newInstance();
//5.獲取方法對象
Method method = cls.getMethod(methodName);
//6.執行方法
method.invoke(obj);
}
我僅僅淺薄的談了一下反射的基本知識，一些比較深刻的理解因爲篇幅問題，放在後面專篇講解，感謝支持。確實有不少不足之處，也但願能與你們交流。
結尾：
若是內容中有什麼不足，或者錯誤的地方，歡迎你們給我留言提出意見, 蟹蟹你們 ！^_^
若是能幫到你的話，那就來關注我吧！（系列文章均會在公衆號第一時間更新）
在這裏的咱們素不相識，卻都在爲了本身的夢而努力 ❤一個堅持推送原創Java技術的公衆號：理想二旬不止
相關文章
- 1. Java反射：Web學習的靈魂
- 2. Java反射（框架設計的靈魂）
- 3. Java反射：框架設計的靈魂
- 4. 框架靈魂——反射
- 5. java:反射知識點初學（框架設計的靈魂）
- 6. 反射是框架設計的靈魂
- 7. 反射-----框架設計的靈魂
- 8. 反射-框架設計的靈魂
- 9. 反射：框架設計的靈魂
- 10. 反射 is 框架的靈魂
- 更多相關文章...
- • C# 反射（Reflection） - C#教程
- • 您已經學習了 Web Services, 下一步學習什麼內容呢？ - Web Services 教程
- • 適用於PHP初學者的學習線路和建議
- • Tomcat學習筆記（史上最全tomcat學習筆記）
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java反射：Web學習的靈魂
- 2. Java反射（框架設計的靈魂）
- 3. Java反射：框架設計的靈魂
- 4. 框架靈魂——反射
- 5. java:反射知識點初學（框架設計的靈魂）
- 6. 反射是框架設計的靈魂
- 7. 反射-----框架設計的靈魂
- 8. 反射-框架設計的靈魂
- 9. 反射：框架設計的靈魂
- 10. 反射 is 框架的靈魂