【類反射】類反射原理和獲取Class對象的三種方式

什么是類反射—原理？

☆什么是反射

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

（2）反射(Reflection)是Java程序開發語言的特征之一，它允許運行中的Java程序對自身進行檢查， 也稱自審，並能直接操作程序的內部屬性。例如，使用它能獲得Java類中各成員的名稱並顯示出來。

（3）Java的這一能力在實際應用中應用得很多，在其它的程序語言中根本就不存在這一特性。例如，Pascal、C或者C++中就沒有辦法在程序中獲得函數定義相關的信息。

（4）JavaBean是類反射的實際應用之一，它能讓一些工具可視化的操作軟件組件。這些工具通過類反射動態的載入並取得Java組件(類)的屬性。后面學習的各種框架，基本上都會有反射的使用。

☆反射引例(HelloWorld、USB)

反射最大的好處就是解耦

1. 最簡單的類反射：（相當於HelloWorld）

   一個ReflectionHelloWorld類演示：

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

/**
 * 1、類反射使用的步驟：<br>
 *      (1)Class c=Class.forName("類全名：包名[.子包名].類名");<br>
 *      (2)調用c對象中的成員方法：Field(字段)、Method(方法)、Constructor(構造方法)、Modifier(靜態方法和常量)<br>
 *      (3)遍歷出所有信息<br>
 */
public class ReflectionHelloWorld {
    public static void main(String[] args) {
        try {
            Class c=Class.forName("cn.yu.reflect.test.UserModel");
            /*
             * 提供有關類或接口的單個字段信息，以及對他的動態訪問權限
             */
            Field[] flds=c.getDeclaredFields();
            for(Field fild:flds){
                System.out.println(fild);
            }
            System.out.println("------------------------");
            /*
             *  提供關於類的單個構造方法的信息以及對它的訪問權限。得到的構造方法只能是public類型的。
             */
            Constructor[] cons=c.getConstructors();
            for(Constructor con:cons){
                System.out.println(con);
            }
            System.out.println("------------------------");
            /*
             * 返回 Method 對象的一個數組，這些對象反映此 Class 對象表示的類或接口聲明的所有方法，
             * 包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法。
             */
            Method[] ms=c.getDeclaredMethods();
            for(Method m:ms){
                System.out.println(m);
            }
            System.out.println("------------------------");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

UserModel類：

import java.io.Serializable;

/**
 * 用戶uuid,name
 */
interface Intera{
    public void aa();
}
public class UserModel implements Serializable{
    private static final long serialVersionUID = 1L;
    private String uuid;
    private String name;
    private int type;
    private String pwd;

    public UserModel(String uuid, String name, int type, String pwd) {
        super();
        this.uuid = uuid;
        this.name = name;
        this.type = type;
        this.pwd = pwd;
    }

    public UserModel(String uuid, String name, int type) {
        super();
        this.uuid = uuid;
        this.name = name;
        this.type = type;
    }

    public UserModel(){

    }
    public void a(){
        System.out.println("我是接口的抽象方法");
    }
    public String getUuid() {
        return uuid;
    }
    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserModel other = (UserModel) obj;
        if (uuid == null) {
            if (other.uuid != null)
                return false;
        } else if (!uuid.equals(other.uuid))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "ID：\t" + uuid + "  , \t" + name + "\t , " + (type);
    }
}

運行結果：

private static final long cn.yu.reflect.test.UserModel.serialVersionUID
private java.lang.String cn.yu.reflect.test.UserModel.uuid
private java.lang.String cn.yu.reflect.test.UserModel.name
private int cn.yu.reflect.test.UserModel.type
private java.lang.String cn.yu.reflect.test.UserModel.pwd
------------------------
public cn.yu.reflect.test.UserModel()
public cn.yu.reflect.test.UserModel(java.lang.String,java.lang.String,int)
public cn.yu.reflect.test.UserModel(java.lang.String,java.lang.String,int,java.lang.String)
------------------------
public java.lang.String cn.yu.reflect.test.UserModel.toString()
public int cn.yu.reflect.test.UserModel.hashCode()
public boolean cn.yu.reflect.test.UserModel.equals(java.lang.Object)
public java.lang.String cn.yu.reflect.test.UserModel.getName()
public int cn.yu.reflect.test.UserModel.getType()
public void cn.yu.reflect.test.UserModel.setName(java.lang.String)
public static long cn.yu.reflect.test.UserModel.getSerialversionuid()
public java.lang.String cn.yu.reflect.test.UserModel.getUuid()
public void cn.yu.reflect.test.UserModel.setType(int)
public void cn.yu.reflect.test.UserModel.setPwd(java.lang.String)
public void cn.yu.reflect.test.UserModel.a()
public java.lang.String cn.yu.reflect.test.UserModel.getPwd()
public void cn.yu.reflect.test.UserModel.setUuid(java.lang.String)
------------------------

反射使用的三個步驟

用於反射的類，如Method，可以在java.lang.reflect包中找到。使用這些類的時候必須要遵循三個步驟：

1. 第一步：獲得你想操作的類的java.lang.Class對象。在運行中的Java程序中，用java.lang.Class類來描述類和接口等。
2. 第二步：調用諸如getDeclaredMethods的方法，取得該類中定義的所有方法的列表。
3. 第三步：使用反射的API來操作這些信息。

如下面這段代碼：

Class c = Class.forName("java.lang.String");
Method ms[] = c.getDeclaredMethods();
System.out.println(ms[0].toString());

它將以文本方式打印出String中定義的第一個方法的原型。

獲取Class對象的三種方式：

★ 方式一

通過對象的getClass方法進行獲取。這種方式需要具體的類和該類的對象，以及調用getClass方法。

★ 方式二

任何數據類型(包括基本數據類型)都具備着一個靜態的屬性class，通過它可直接獲取到該類型對應的Class對象。這種方式要使用具體的類，然后調用類中的靜態屬性class完成，無需調用方法，性能更好。

★ 方式三

通過Class.forName()方法獲取。這種方式僅需使用類名，就可以獲取該類的Class對象，更有利於擴展。

代碼演示：

import org.junit.Test;
/**
 * 1、演示獲取Class c對象的三種方法
 */
public class ReflectGetClass {

    /**
     * 法1：通過對象---對象.getClass()來獲取c(一個Class對象)
     */
    @Test
    public void get1(){
        Person p=new Person("Jack", 23);
        Class c=p.getClass();//來自Object方法
    }

    /**
     * 法2：通過類(類型)---任何數據類型包括(基本數據類型)都有一個靜態的屬性class ，他就是c 一個Class對象
     */
    @Test
    public void get2(){
        Class c=Person.class;
        Class c2=int.class;
    }

    /**
     * 法3：通過字符串(類全名 )---能夠實現解耦：Class.forName(str)
     */
    @Test
    public void get3(){
        try {
            Class c=Class.forName("cn.hncu.reflect.test.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}