【java提高】---java反射機制

java反射機制

 

一、概述

1、什么是反射機制

       反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。

2、反射機制能做什么

反射機制主要提供了以下功能：

        1) 在運行時判斷任意一個對象所屬的類；

        2) 在運行時構造任意一個類的對象；

        3) 在運行時判斷任意一個類所具有的成員變量和方法；

        4) 在運行時調用任意一個對象的方法；

        5) 生成動態代理。

3、反射的優點和缺點

為什么要用反射機制？直接創建對象不就可以了嗎，這就涉及到了動態與靜態的概念：

        靜態編譯：在編譯時確定類型，綁定對象,即通過。

        動態編譯：運行時確定類型，綁定對象。動態編譯最大限度發揮了java的靈活性，體現了多態的應用，有以降低類之間的藕合性。

一句話，反射機制的優點就是可以實現動態創建對象和編譯，體現出很大的靈活性，特別是在J2EE的開發中它的靈活性就表現的十分明顯。

比如，一個大型的軟件，不可能一次就把把它設計的很完美，當這個程序編譯后，發布了，當發現需要更新某些功能時，我們不可能要用戶把以前的卸載，再重新安裝新的版本，假如 這樣的話，這個軟件肯定是沒有多少人用的。采用靜態的話，需要把整個程序重新編譯一次才可以實現功能的更新，

而采用反射機制的話，它就可以不用卸載，只需要在運行時才動態的創建和編譯，就可以實現該功 能。 

它的缺點是對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什么並且它 滿足我們的要求。這類操作總是慢於只直接執行相同的操作。 

4、反射的原理

        JAVA語言編譯之后會生成一個.class文件，這些 Class 對象承載了這個類型的父類、接口、構造函數、方法、屬性等原始信息，這些 class 文件在程序運行時會被 ClassLoader 加載到虛擬機中。

反射就是通過字節碼文件找到某一個類、類中的方法以及屬性等。

5、反射的應用場景

個人覺得使用反射機制的一些地方：

      1) 工廠模式：Factory類中用反射的話，添加了一個新的類之后，就不需要再修改工廠類Factory了

      2) 動態代理模式

      3) 數據庫JDBC中通過Class.forName(Driver).來獲得數據庫連接驅動

      4) 分析類文件：畢竟能得到類中的方法等等

 

二、反射常用方法

利用反射機制能獲得類的所有信息 ，類中有什么信息，它就可以獲得什么信息。

反射的實現主要借助以下四個類

       Class：類的對象

       Constructor：類的構造方法

       Field：類中的屬性對象

       Method：類中的方法對象

我們知道所有類的對象其實都是Class的實例，所以要獲得對象，首先要獲得class實例

1、獲得class實例三種方法

Class<?> demo1=Class.forName("com.jincou.study.Demo"); //一般推薦這種
Class<?> demo2=new Demo().getClass();
Class<?> demo3=Demo.class;

獲得class對象后，我們就可以通過class對象獲得實際對象

Demo obj=(Demo)demo1.newInstance();//創建對象的實例，這里需要一個無參的構造函數 

OK，有了對象就什么都好辦了，想要什么信息就有什么信息了。

2、獲得構造函數

Constructor getConstructor(Class[] params)//根據指定參數獲得public構造器
Constructor[] getConstructors()           //獲得public的所有構造器
Constructor getDeclaredConstructor(Class[] params)//根據指定參數獲得public和非public的構造器
Constructor[] getDeclaredConstructors()   //獲得public的所有構造器

3、獲得類方法

Method getMethod(String name, Class[] params)         //根據方法名，參數類型獲得方法
Method[] getMethods()         //獲得所有的public方法
Method getDeclaredMethod(String name, Class[] params) //根據方法名和參數類型，獲得public和非public的方法
Method[] getDeclaredMethods() //獲得所以的public和非public方法 

4、獲得類中屬性

Field getField(String name)  //根據變量名得到相應的public變量
Field[] getFields()          //獲得類中所以public的方法
Field getDeclaredField(String name)//根據方法名獲得public和非public變量
Field[] getDeclaredFields()  //獲得類中所有的public和非public方法

 

三、綜合小案例

上面的都是講解理論，主要是日后可以當做自己的查找的API來用，下面來一個綜合小案例來加深對它的理解：

package com.jincou.study;

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

public class Main {  
    /** 
     * 為了看清楚Java反射部分代碼，所有異常我都最后拋出來給虛擬機處理！ 
     */  
    public static void main(String[] args) throws Exception {  

        System.out.println("Demo1===============================================");    
        //Demo1.  通過Java反射機制得到類的包名和類名  
        Demo1();  
        
        System.out.println("Demo2===============================================");  
        //Demo2.  驗證所有的類都是Class類的實例對象  
        Demo2();  
       
        System.out.println("Demo3===============================================");     
        //Demo3.  通過Java反射機制，用Class 創建類對象[這也就是反射存在的意義所在]，無參構造  
        Demo3();  
       
        System.out.println("Demo4===============================================");  
        //Demo4:  通過Java反射機制得到一個類的構造函數，並實現構造帶參實例對象  
        Demo4();  
          
        System.out.println("Demo5===============================================");    
        //Demo5:  通過Java反射機制操作成員變量, set 和 get  
        Demo5();  
        
        System.out.println("Demo6===============================================");     
        //Demo6: 通過Java反射機制得到類的一些屬性： 繼承的接口，父類，函數信息，成員信息，類型等  
        Demo6();  
        
        System.out.println("Demo7===============================================");    
        //Demo7: 通過Java反射機制調用類中方法  
        Demo7();  
       
        System.out.println("Demo8===============================================");   
        //Demo8: 通過Java反射機制獲得類加載器  
        Demo8();  
                    
    }  
      
    /** 
     * Demo1: 通過Java反射機制得到類的包名和類名 
     */  
    public static void Demo1()  
    {  
        Person person = new Person();  
        System.out.println("包名:" + person.getClass().getPackage().getName());  
        System.out.println("完整類名:" + person.getClass().getName()); 
    }  
      
    /** 
     * Demo2: 驗證所有的類都是Class類的實例對象 
     */  
    public static void Demo2() throws ClassNotFoundException  
    {  
        //定義兩個類型都未知的Class , 設置初值為null, 看看如何給它們賦值成Person類  
        Class<?> class1 = null;  
        Class<?> class2 = null;  
          
        //寫法1, 可能拋出 ClassNotFoundException [多用這個寫法]  
        class1 = Class.forName("com.jincou.study.Person");  
        System.out.println("(寫法1) 包名: " + class1.getPackage().getName() + "，"   
                + "完整類名: " + class1.getName());  
          
        //寫法2  
        class2 = Person.class;  
        System.out.println("(寫法2) 包名: " + class2.getPackage().getName() + "，"   
                + "完整類名: " + class2.getName());  
    }  
      
    /** 
     * Demo3: 通過Java反射機制，用Class 創建類對象[這也就是反射存在的意義所在]   
     */  
    public static void Demo3() throws Exception 
    {  
        Class<?> class1 = null;  
        class1 = Class.forName("com.jincou.study.Person");  
        //由於這里不能帶參數，所以你要實例化的這個類Person，一定要有無參構造函數哈～  
        Person person = (Person) class1.newInstance();  
        person.setAge(20);  
        person.setName("張三");  
        System.out.println("name: " + person.getName() + " age: " + person.getAge());  
    }  
      
    /** 
     * Demo4: 通過Java反射機制得到一個類的構造函數，並實現創建帶參實例對象  
     */  
    public static void Demo4() throws Exception  
    {  
        Class<?> class1 = null;  
        Person person1 = null;  
        Person person2 = null;  
          
        class1 = Class.forName("com.jincou.study.Person");  
        //得到一系列構造函數集合  
        Constructor<?>[] constructors = class1.getConstructors();           
        //無參構造函數
        person1 = (Person) constructors[0].newInstance();  
        person1.setAge(30);  
        person1.setName("李四");
        //有參構造函數
        person2 = (Person) constructors[1].newInstance(20,"王五");  
          
        System.out.println("name: " + person1.getName() + " age: " + person1.getAge() );  
        System.out.println("name: " + person2.getName() + " age: " + person2.getAge() );     
    }  
      
    /** 
     * Demo5: 通過Java反射機制操作成員變量, set 和 get 
     */  
    public static void Demo5() throws Exception
    {  
        Class<?> class1 = null;  
        class1 = Class.forName("com.jincou.study.Person");  
        Object obj = class1.newInstance();  
        
        //獲取com.jincou.study.Person.name的屬性名
        Field personNameField = class1.getDeclaredField("name");  
        personNameField.setAccessible(true);  
        personNameField.set(obj, "張三");  
                   
        System.out.println("修改屬性之后得到屬性變量的值：" + personNameField.get(obj));        
    }  
      
    /** 
     * Demo6: 通過Java反射機制得到類的一些屬性： 繼承的接口，父類，函數信息，成員信息，類型等  
     */  
    public static void Demo6() throws ClassNotFoundException  
    {  
        Class<?> class1 = null;  
        class1 = Class.forName("com.jincou.study.SuperMan");  
          
        //取得父類名稱  
        Class<?>  superClass = class1.getSuperclass();  
        System.out.println("SuperMan類的父類名: " + superClass.getName());  
          
        //取得屬性信息         
        Field[] fields = class1.getDeclaredFields();  
        for (int i = 0; i < fields.length; i++) {  
            System.out.println("類中的成員: " + fields[i]);  
        }  
            
        //取得類方法  
        Method[] methods = class1.getDeclaredMethods();  
       
       // 取得SuperMan類的方法
            System.out.println("函數名：" + methods[0].getName());   
            System.out.println("函數代碼寫法： " + methods[0]);  
                      
        //取得類實現的接口,因為接口類也屬於Class,所以得到接口中的方法也是一樣的方法得到哈  
        Class<?> interfaces[] = class1.getInterfaces();  
        for (int i = 0; i < interfaces.length; i++) {  
            System.out.println("實現的接口類名: " + interfaces[i].getName() );  
        }  
          
    }  
      
    /** 
     * Demo7: 通過Java反射機制調用類方法 
     */  
    public static void Demo7() throws Exception  
    {  
        Class<?> class1 = null;  
        class1 = Class.forName("com.jincou.study.SuperMan");  
          
       //調用fly()方法
        Method method = class1.getMethod("fly");  
        method.invoke(class1.newInstance());  

        //調用walk(int m)方法  
        method = class1.getMethod("walk",int.class);  
        method.invoke(class1.newInstance(),100);  
    }  
      
    /** 
     * Demo8: 通過Java反射機制得到類加載器信息 
     */  
    public static void Demo8() throws ClassNotFoundException  
    {  
        Class<?> class1 = null;  
        class1 = Class.forName("com.jincou.study.SuperMan");  
        String nameString = class1.getClassLoader().getClass().getName();  
          
        System.out.println("類加載器類名: " + nameString);  
    }  
                
}  
/**
 * Person類 
 */  
class  Person{  
    private int age;  
    private String name;  
    public Person(){  
          
    }  
    public Person(int age, String name){  
        this.age = age;  
        this.name = name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
}  
 
 //SuperMan類
class SuperMan extends Person implements ActionInterface  
{  
    private boolean BlueBriefs;  
      
    public void fly()  
    {  
        System.out.println("我是fly方法......");  
    }  
      
    public boolean isBlueBriefs() {  
        return BlueBriefs;  
    }  
    public void setBlueBriefs(boolean blueBriefs) {  
        BlueBriefs = blueBriefs;  
    }  
  
    @Override  
    public void walk(int m) {  
        System.out.println("我是walk方法，我的int值為：" + m );  
    }  
} 
//ActionInterface接口
interface ActionInterface{  
    public void walk(int m);  
}  

查看運行結果：

 

  想太多，做太少，中間的落差就是煩惱。想沒有煩惱，要么別想，要么多做。中校【2】