Java反射機制是什麼？ Java反射機制的使用方法

這篇文章帶給大家的內容是關於Java反射機制是什麼？ Java反射機制的使用方法，有一定的參考價值，有需要的朋友可以參考一下，希望對你有幫助。

說到反射機制，第一次接觸的人可能會比較懵，反射?什麼反射？怎麼反射？反射是乾嘛的？下面我將在這篇文章中講講Java的反射機

不過在這之前，還有一個問題需要解決，標題名中的動態性，說起動態性，我先介紹介紹動態語言和靜態語言

#靜態語言

#　　靜態語言是在編譯時變數的資料類型即可確定的語言，多數靜態類型語言要求在使用變數之前必須聲明資料類型。 例如：C 、Java、Delphi、C#等。

動態語言

#　　動態語言是執行時間決定資料類型的語言。變數使用之前不需要型別聲明，通常變數的型別是被賦值的那個值的型別。 例如PHP/ASP/Ruby/Python/Perl/ABAP/SQL/JavaScript/Unix Shell等等。 且動態語言，是指程式在執行時可以改變其結構：新的函數可以引進，已有的函數可以被刪除等結構上的變化。

　　這時可能你就會有疑問了，既然Java屬於靜態語言，又怎麼會有動態性?其一就是Java存在與動態性相關的機制：反射機制。 Java透過反射機制，可以在程式執行時加載，探知和使用編譯期間完全未知的類，並且可以產生相關類物件實例，從而可以呼叫其方法或則改變某個屬性值。 所以JAVA也可以算是一個半動態的語言

#下面來講反射機制

　　反射機制概念
　　　　在Java中的反射機制是指在運作狀態中，對於任何一個類別都能夠知道這個類別所有的屬性和方法；並且對於任意一個對象，都能夠呼叫它的任意一個方法；這種動態獲取資訊以及動態呼叫對象方法的功能稱為Java語言的反射機制。

　 反射的原理在於Class物件

　　　　看一看程式載入的過程

從圖中大概可以看出反射是做什麼用的了，那接下來就講講有關反射的其他面向

　　反射的API

　　　　反射API用來產生JVM中的類別、介面或則物件的資訊。
　　　　- Class類：反射的核心類，可以取得類別的屬性，方法等資訊。
　　　　- Field類別：Java.lang.reflec套件中的類，表示類別的成員變量，可以用來取得和設定類別之中的屬性值。
　　　　- Method類別： Java.lang.reflec套件中的類，表示類別的方法，它可以用來取得類別中的方法資訊或執行方法。
　　　　- Constructor類別： Java.lang.reflec套件中的類，表示類別的建構方法。

下面就來講講怎麼使用反射了　　

1.步驟

##取得想要操作的類別的Class物件

呼叫Class類別中的方法

使用反射API來操作這些資訊

 2.取得Class物件的方法

//假设我们有一个Student类
方法一、(推荐)
    Class clas = Class.forName("first.Student");//“”里写的是类的全路径

方法二、
    Student stu = new Student();
    Class clas = stu.getClass();

方法三、
    Class clas = Student.Class;

##可以試試看用兩個不同的方法來取得clas1和clas2，然後System.ou.println(clas1==clas2)看看會輸出什麼，原因在圖上#########3.取得建構方法、欄位、main方法並呼叫############Student.java#############

public class Student {
    public String name;
    protected int age;
    char sex;
    private String phoneNum;
    
    public static void main(String[] args) {

        System.out.println("main方法执行了。。。");

    }
    //---------------构造方法-------------------
    Student(String str) {
        System.out.println("(默认)的构造方法 s = " + str);
    }

    // 无参构造方法
    public Student() {
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }

    // 有一个参数的构造方法
    public Student(char name) {

        System.out.println("姓名：" + name);
    }

    // 有多个参数的构造方法
    public Student(String name, int age) {
        this.name=name;this.age=age;
        System.out.println("姓名：" + name + "年龄：" + age);// 这的执行效率有问题，以后解决。
    }

    // 受保护的构造方法
    protected Student(boolean n) {
        System.out.println("受保护的构造方法 n = " + n);
    }

    // 私有构造方法
    private Student(int age) {
        System.out.println("私有的构造方法   年龄：" + age);
    }
    
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex
                + ", phoneNum=" + phoneNum + "]";
    }
}

######

Constructors.java（构造方法）

package first;

import java.lang.reflect.Constructor;

public class Constructors {
    public static void main(String[] args) throws Exception {
        
        Class clas=Class.forName("first.Student");
        
        System.out.println("所有公有构造方法");
        Constructor[] conArry=clas.getConstructors();
        for(int i=0;i<conArry.length;i++) {
            System.out.println(conArry[i]);
        }
        
        System.out.println("所有的构造方法");
        conArry=clas.getDeclaredConstructors();
        for(int i=0;i<conArry.length;i++) {
            System.out.println(conArry[i]);
        }
        
        System.out.println("获取公有无参的构造方法");
        Constructor con=clas.getConstructor(null);
        System.out.println("con="+con);
        Object obj=con.newInstance();
        
        System.out.println("获取私有构造方法，并调用");
        con=clas.getDeclaredConstructor(char.class);
        System.out.println(con);
        //con.setAccessible(true);//暴力访问，针对private方法和字段时使用
        obj=con.newInstance(&#39;a&#39;);//创建对象
    }
}

输出

所有公有构造方法
public first.Student(char)
public first.Student()
public first.Student(java.lang.String,int)
所有的构造方法
protected first.Student(boolean)
private first.Student(int)
public first.Student(char)
public first.Student()
first.Student(java.lang.String)
public first.Student(java.lang.String,int)
获取公有无参的构造方法
con=public first.Student()
调用了公有、无参构造方法执行了。。。
获取私有构造方法，并调用
public first.Student(char)
姓名：a

Fields.java（字段）

package first;
import java.lang.reflect.Field;
public class Fields {
    public static void main(String[] args)throws Exception {
        // TODO Auto-generated method stub
        Class StuClass=Class.forName("first.Student");
        
        System.out.println("获取所有公有的字段");
        Field[] fieldArry=StuClass.getFields();
        for(Field f:fieldArry) {
            System.out.println(f);
        }
        System.out.println("获取所有的字段(包括私有、受保护、默认的)");
        fieldArry=StuClass.getDeclaredFields();
        for(Field f:fieldArry) {
            System.out.println(f);
        }
        System.out.println("获取公有字段并调用");
        Field f = StuClass.getField("name");
        System.out.println(f);
        Object obj=StuClass.getConstructor().newInstance();
        StuClass.getConstructor(String.class,int.class).newInstance("a",10);
        f.set(obj, "b");
        Student stu=(Student)obj;
        System.out.println(stu.name);
        
        System.out.println("获取私有字段并调用");
        f = StuClass.getDeclaredField("phoneNum");
        System.out.println(f);
        f.setAccessible(true);//暴力反射，解除私有限定
        f.set(obj, "18888889999");
        System.out.println("验证电话：" + stu);
    }
}

输出

获取所有公有的字段
public java.lang.String first.Student.name
获取所有的字段(包括私有、受保护、默认的)
public java.lang.String first.Student.name
protected int first.Student.age
char first.Student.sex
private java.lang.String first.Student.phoneNum
获取公有字段并调用
public java.lang.String first.Student.name
调用了公有、无参构造方法执行了。。。
姓名：a年龄：10
b
获取私有字段并调用
private java.lang.String first.Student.phoneNum
验证电话：Student [name=b, age=0, sex=

Main.java

package first;
import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) {
        try {
            // 1、获取Student对象的字节码
            Class clazz = Class.forName("first.Student");

            // 2、获取main方法

            Method methodMain = clazz.getMethod("main", String[].class);// 第一个参数：方法名称，第二个参数：方法形参的类型，

            // 3、调用main方法
            // methodMain.invoke(null, new String[]{"a","b","c"});
            // 第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组
            // 这里拆的时候将 new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
            methodMain.invoke(null, (Object) new String[] {});// 方式一
            // methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上是Java反射機制是什麼？ Java反射機制的使用方法的詳細內容。更多資訊請關注PHP中文網其他相關文章！