2. 程式人生 > >反射（Constructor、Field、Method、類載入器）

反射（Constructor、Field、Method、類載入器）

阿新 • • 發佈：2018-12-05

一：什麼是反射
在認識反射之前，首先回顧下什麼是正向處理。如果我們需要例項化一個物件，首先需要匯入這個類的包，在這個包中找這個類：

package CODE.反射;

import java.util.Date;

public class Fan {
    public static void main(String[] args) {
        Date date =new Date();
        System.out.println(date);
    }
}

例項化一個Date物件，需要根據包名.類名來找到Date類。
而反射是相反：是根據物件來取得物件的來源資訊。
也就是物件的反向處理。根據物件倒推類的組成。
反射核心處理在於Object類的方法：

//取得類的Class 物件（Class是一個類）
public final native Class<?> getClass();

package CODE.反射;

import java.util.Date;

public class Fan {
    public static void main(String[] args) {
        Date date =new Date();
        //取得data物件的Date類資訊
        System.out.println(date.getClass()); //class java.util.Date
 

    }
}

Class物件的3種例項化方法：
任何一個類的Class物件由JVM載入類後產生（該物件在JVM全域性唯一）。使用者呼叫指定方法來取得該類物件。

  • 任何類的物件可以通過Object類提供的getClass()取得該類Class物件
  • “類名稱.class”可以直接根據某個具體的類來取得Class物件
  • 呼叫Class類的靜態方法Class.forName(String className) throws
    ClassNotFoundException,傳入類的全名稱來取得其Class物件。
import java.util.Date;

public
 
 class Fan {
    public static void main(String[] args) throws ClassNotFoundException {
        Date date =new Date();
        Class<?> cls1 =date.getClass();
        Class<?> cls2=Class.forName("java.util.Date");
        Class<?> cls3=Date.class;
        System.out.println(cls1); //class java.util.Date   
        System.out.println(cls1); //class java.util.Date
        System.out.println(cls1); //class java.util.Date
    }
}

class java.util.Date 前面的class表明是一個類物件。
從理論和例項看出，只有第一種方式需要例項化物件來取得Class物件，其餘2種方式不會產生例項化物件。那麼取得了Class類物件後可以通過反射來例項化物件。

用反射來例項化物件
在Class類中有一個方法可以通過Class物件來例項化物件：

public T newInstance()  throws InstantiationException, IllegalAccessException

只能呼叫類中無參構造，且無參構造只能是public許可權。
只有當例項化出Class物件後才可以用Class物件調newInstance。
例：

////通過反射例項化物件
import java.util.Date;

public class Fan {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
       Class<?> cls1=Date.class;  //Class物件
       Object obj=cls1.newInstance(); //例項化物件，相當於new java.util.Date()
       System.out.println(obj);
    }
}

完善簡單工廠模式----利用反射
之前在寫工廠模式時，在Factory裡new物件，但是有一個缺陷，就是新增一個類，需要在Factory裡再新增一個分支來new物件。可以參考這篇部落格：
但是有了反射後，可以用Class 物件來例項化物件（有2種產生Class物件不需要例項化物件：Class.forName()和類名.class）
程式碼如下：

package CODE.反射;

//工廠模式---反射

interface Study
{
    void need();
}
class Pen implements Study
{
   public void need()
   {
       System.out.println("需要一直筆");
   }
}
class Book implements Study
{
    public void need()
    {
        System.out.println("需要一個本子");
    }
}
class Pencil implements Study
{
    public void need()
    {
        System.out.println("需要一隻鉛筆");
    }
}
class Factory1
{
    public static Study getStudy(String className)
    {
        Study study=null;
        try {
            //cls是一個Class類物件  通過className取得具體Class物件
            Class<?> cls=Class.forName(className);
            //通過反射例項化物件
            //因為newInstance返回的是Object，所以需要強轉稱為一個型別
            study=(Study)cls.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return study;
    }
}
public class FanSheFac {
    public static void main(String[] args)
    {
        Study study1=Factory1.getStudy("CODE.反射.Pen");
        study1.need();  //需要一直筆
        Study study2=Factory1.getStudy("CODE.反射.Pencil");
        study2.need();  //需要一隻鉛筆
    }
}

在這裡插入圖片描述

反射與類

取得類的包名：

 public Package getPackage() {
        return Package.getPackage(this);
    }

如：

import java.util.Date;

public class Fan {
    public static void main(String[] args)  {
        Class<?> cls1=Date.class;
        System.out.println(cls1.getPackage()); //package java.util, Java Platform API Specification, version 1.8
        System.out.println(cls1.getPackage().getName()); //java.util 利用getName取得具體包名
    }
}

1.反射取得父類、父介面資訊

  • 取得父類的Class物件：public native Class<? super T> getSuperclass();
  • 取得父介面的Class物件：public Class<?>[ ] getInterfaces()；（介面在JVM中也是Class因為介面有多繼承，所以父介面可能有多個）
package CODE.反射;

//反射與類操作
//取得父類的Class物件
class A{}
interface IB{}
interface  IC{}
class ABC extends A implements IB,IC{}
public class FanClass {
    public static void main(String[] args) {
        Class<?> cls=ABC.class; //獲得Class物件

        //獲得父類Class物件
        Class<?> cls1=cls.getSuperclass();
        System.out.println("父類Class物件:"+cls1);
        //父類Class物件:class CODE.反射.A

        //獲得父介面Class物件
        Class<?>[] cls2=cls.getInterfaces();
        for(Class<?> clas:cls2)
        {
            System.out.println("父介面Class物件:"+clas);
            //父介面Class物件:interface CODE.反射.IB
            //父介面Class物件:interface CODE.反射.IC
        }
    }
}

2.反射呼叫類中構造方法–Constructor類（描述類中構造方法）

一個類有多個構造，如果要想取得類中構造方法，可以使用Class類提供的2個方法：

  • 取得指定引數型別的構造：
public Constructor<T> getConstructor(Class<?>... parameterTypes)   throws NoSuchMethodException, SecurityException
只能取得類中public許可權的指定構造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)    throws NoSuchMethodException, SecurityException
可以取得類中全部指定構造方法，包含私有構造

引數是型別的類物件，比如型別是String，那麼引數是String.class。

  • 取得類中所有構造方法
public Constructor<?>[] getConstructors() throws SecurityException
取得所有public許可權構造方法

public Constructor<?>[] getDeclaredConstructors() throws SecurityException
取得所有許可權構造方法（包括私有許可權）

動態設定封裝(只能通過反射呼叫)
Constructor /Method/Field類都AccessibleObjet的子類。
AccessibleObjet提供動態設定封裝方法
public void setAccessible(boolean flag) throws SecurityException
setAccessible只能在本次JVM程序中有效，重新啟動時，private許可權方法依然不可以在外部使用，也就是說只是動態破壞了本次的封裝。

Constructor提供了例項化物件的方法：
public T newInstance(Object … initargs) :可以呼叫類中其他有參構造。

Constructor類的newInstance(Object … initargs)與Class類的newInstance( )區別：
1.Constructor類的例項化物件方法引數有可變引數，即可以有引數，也可以沒有引數，Class類提供的例項化物件方法必須是無參。
2.當有了Constructor物件後，也就是取得類的構造方法，假如構造方法是私有許可權，可以利setAccessible(true)動態破壞私有構造用newInstance例項化物件，而Class類的newInstance只有用public許可權構造方法來例項化物件。

程式碼如下：

package CODE.反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

////反射與構造
class Student
{
    private String name;
    private int sno;

    public Student()
    {
    }
    private Student(String  name, int sno) {
        this.name = name;
        this.sno = sno;
    }
    public String toString()
    {
        return "姓名:"+name+"學號"+sno;
    }
}
public class FanConstruct {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> cls=Student.class;
        Constructor<?> constructor=cls.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        //Constructor類提供的newInstance()方法例項化物件 ，引數是要設定的值
        //可以通過Constructor類提供的setAccessible使動態破壞許可權，設定為true後，private許可權可以在外部使用
        //但是也是在在本次JVM程序有效，重新啟動後依然是private許可權
        System.out.println(constructor.newInstance("pick",10)); //姓名:pick學號10
    }
}

3.反射呼叫類中普通方法-- - -Method（描述類中普通方法）

  • 描述類中指定名稱的普通方法
public Method getMethod(String name, Class<?>... parameterTypes)  throws NoSuchMethodException, SecurityException
取得本類和父類中public許可權指定方法

public Method getDeclaredMethod(String name, Class<?>... parameterTypes)  throws NoSuchMethodException, SecurityException
取得本類任何許可權的指定方法（私有、公有、繼承許可權）

引數中String nama ：方法名
parameterTypes：引數型別的類物件，如String.class ,既要傳方法名，又要傳型別是為了過載。

  • 取得類中全部普通方法
public Method[] getMethods() throws SecurityException 
取得本類和父類中所有public許可權方法

public Method[] getDeclaredMethods() throws SecurityException
取得本類中所有許可權方法（注意只有本類）

例：

package CODE.反射;

import java.lang.reflect.Method;

class Person1
{
    public void print1(){}
    private void print2(){}
    public void print3(String str){}
}
class Student1 extends Person1
{
    public void print2(int m){
    }
    private void print3(int a){}
}
public class FanSheMeth {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException {
        Class<?> cls=Student1.class;

        Student1 student1=(Student1)cls.newInstance(); //通過反射取得例項化物件
        Method method1[]=cls.getDeclaredMethods();
        Method method2[]=cls.getMethods();
        Method method3=cls.getMethod("print3",String.class);
        Method method4=cls.getDeclaredMethod("print3", int.class);
        System.out.println("getDeclaredMethods取得本類中所有許可權方法：");
        for(Method me1:method1)
        {
            System.out.println(me1);
        }
        System.out.println("getMethods取得本類和父類中所有public許可權方法");
        for(Method me2:method2)
        {
            System.out.println(me2);
        }
        System.out.println("getMethod取得本類和父類所有public許可權指定方法:");
        System.out.println(method3);
        System.out.println("getDeclaredMethod取得本類中public許可權指定方法");
        System.out.println(method4);
    }
}

在這裡插入圖片描述

Method類中提供呼叫類中普通方法的API：
public Object invoke(Object obj, Object… args)
如:

package CODE.反射;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Person
{
    private String name;
    private int age;
    public void print(String name,int age)
    {
        this.name=name;
        this.age=age;
        System.out.println("name:"+this.name+" age:"+this.age);
    }
    private void print(String str)
    {
        System.out.println(str);
    }
}

public class Meth
{
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> cls=Person.class;
        Person person=(Person)cls.newInstance();
        Method printMeth=cls.getMethod("print",String.class,int.class);
        printMeth.invoke(person,"pick",10); //name:pick age:10

        //Method物件調set
        Method printStr=cls.getDeclaredMethod("print", String.class); //取得本類本任意許可權方法
        printStr.setAccessible(true);  //動態破壞許可權，使私有許可權可見
        printStr.invoke(person,"nice day"); //nice day
    }
}

4.反射呼叫類中屬性----Field（描述類中普通屬性）

  • 取得類中指定屬性
public Field getField(String name) throws NoSuchFieldException, SecurityException
取得本類和父類中public指定許可權屬性

public Field getDeclaredField(String name)
throws NoSuchFieldException, SecurityException
取得本類任意許可權屬性（私有、公有、繼承、預設）
  • 取得類中所有屬性
public Field[] getFields() throws SecurityException
取得本類以及父類中所有public屬性

public Field[] getDeclaredFields() throws SecurityException
取得本類中全部普通屬性（包括私有屬性）

Field類提供設定與取得屬性：

設定屬性：
public void set(Object obj,Object value);
obj:例項化物件，value：具體的值

取得屬性：
pulic Object get(Object obj);

取得屬性的型別：
pubic Class<?> getType

對上述方法進行驗證和練習：

package CODE.反射;

import com.sun.corba.se.impl.orbutil.concurrent.Sync;

import java.lang.reflect.Field;

class Person2
{
    private String name;
    private int age;
    public int count=10;
}

class Student2 extends Person2
{
    public int num=1;
    private String sno; //課程號
}
public class FanSheField {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class<?> cls=Student2.class;
        Student2 student2=(Student2)cls.newInstance();
        System.out.println("getField取得本類和父類中public許可權屬性:");
        Field count=cls.getField("count");
        count.set(student2,1);  //設定值
        System.out.println("Field取得本類公有屬性值: "+count+":"+count.get(student2));

        System.out.println("getDeclaredField取得本類任意許可權屬性");
        Field sno=cls.getDeclaredField("sno");
        sno.setAccessible(true);  //破壞私有許可權
        sno.set(student2,"3");
        System.out.println("Field取得本類私有許可權屬性值: "+sno+":"+sno.get(student2));
        System.out.println("取得屬性型別:"+sno.getType());

        System.out.println("getFields取得本類和父類所有公有許可權屬性");
        Field field1[]=cls.getFields();
        for(Field f1: field1)
        {
            System.out.println(f1);
        }

        System.out.println("getDeclaredFields取得本類所有許可權屬性");
        Field field2[]=cls.getDeclaredFields();
        for(Field f2:field2)
        {
            System.out.println(f2);
        }
    }
}

在這裡插入圖片描述
在這裡插入圖片描述
在這裡插入圖片描述
反射應用：
實現任意類屬性設定。
如果希望對一個類的屬性進行設定，當輸入字串是"emp.name:pick | emp.job:cook"時，emp是真實類中屬性，name和job是類中屬性名稱，“pick"和"cook"是要設定的值，兩個屬性用”|"進行分割，如果可以將屬性設定為此種格式，可以一次性將屬性設定完畢。
程式碼如下：
emp是真實類，EmpAction是面向使用者的類，BeanOperation是公共操作類（任意類通過這個類來設定屬性）：
Emp.java

package CODE.反射與簡單Java類;

public class Emp {
    private String name;
    private String job;

    public String getName<

相關推薦

反射（Constructor、Field、Method、類載入器）

一：什麼是反射 在認識反射之前，首先回顧下什麼是正向處理。如果我們需要例項化一個物件，首先需要匯入這個類的包，在這個包中找這個類： package CODE.反射; import java.util.Date; public class Fan { public static

JVM（三）：類載入機制（類載入過程和類載入器）

一、為什麼要使用類載入器？Java語言裡，類載入都是在程式執行期間完成的，這種策略雖然會令類載入時稍微增加一些效能開銷，但是會給java應用程式提供高度的靈活性。例如：1.編寫一個面向介面的應用程式，可能等到執行時再指定其實現的子類；2.使用者可以自定義一個類載入器，讓程式在

類載入器、反射，反射的應用例項（泛型擦除和配置檔案）

類載入器 1.1類的載入 當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連線，初始化三步來實現對這個類進行初始化。   1.1.1載入 指將class檔案讀入記憶體，併為之建立一個Class物件。 任何類被使用時系統都會建立一個Class物件（位元組碼檔案物件，建

BOS項目 第2天（BaseDao、BaseAction、用戶登錄、自定義strust登錄攔截器）

XML sage pdm nat cls his jquer als 是否一致 BOS項目 第2天 今天內容安排： 1、根據提供的pdm文件生成sql 2、持久層和表現層設計---BaseDao、BaseAction 3、實現用戶登錄功能 4、jQuery EasyUI

第二天筆記-選擇器（標籤選擇器、類選擇器、css命名規範、谷歌案例、多類名選擇器、id選擇器、萬用字元選擇器、偽類選擇器）

四、選擇器 要想將CSS樣式應用於持定的HTML元素，首先需要找到該目標元素。在CSS中，執行這一任務的樣式規則部分則成為選擇器（選擇符）。 （一）標籤選擇器（元素選擇器） 標籤選擇器是隻用於HTML標籤名作為選擇器，按標籤名分類，為頁面中某一類標籤指定統

十、JAVA多執行緒：JVM類載入器（自動類載入器、雙親委託機制、類載入器名稱空間、執行時包、類的解除安裝等）

  Jvm提供了三大內建的類載入器，不同的類載入器負責將不同的類載入到記憶體之中 根載入器（Bootstrap ClassLoader） 是最頂層的載入器，是由C++編寫的，主要負責虛擬機器核心類庫的載入，如整個java.lang包，根載入器是獲取不到引用的，因此

深入JVM系列（三）之類載入、類載入器、雙親委派機制與常見問題

一．概述 定義：虛擬機器把描述類的資料從Class檔案載入到記憶體，並對資料進行校驗、轉換解析和初始化，最終形成可以被虛擬機器直接使用的java型別。類載入和連線的過程都是在執行期間完成的。 二.

Java類載入器( CLassLoader ) 死磕 1、2: 匯入 & 分類

JAVA類載入器 死磕系列 目錄 by   瘋狂創客圈 1.匯入1.1. 從class檔案的載入開始1.2. 什麼是類載入器2. JAVA類載入器分類2.1. 作業系統的環境變數2.2. Bootstrap ClassLoader（啟動類載入器）2.3. Extention ClassL

Java原始碼分析——Class類、ClassLoader類解析(三)　類載入器、實現自定義類載入器

    在這個系列的第一篇章就講解了Class類的獲取以及載入過程，但是並沒有提及具體的載入過程，在java中，載入一個類是通過ClassLoader類來執行的，也就是類載入器完成。java中所有的類，都必須載入進jvm中才能執行，這個載入的意思是

JAVA類載入器、註解和動態代理

一.類載入器 1.什麼是類載入器，作用是什麼 類載入器就載入位元組碼檔案（.class） 2.類載入器的種類 類載入器有三種，不同載入器載入不同 BootStrap：引導類載入器：載入都是最基礎的檔案 ExtClassLoader：擴充套

高新技術---> 註解、類載入器

第一  註解 一、概述： 1、註解是JDK1.5出現的新特性 2、註解相當於一種標記，在程式中加了註解就等於為程式打上了某種標記，沒加，則沒有某種標記。 3、加了註解以後，java編譯器、開發工具和其他應用程式就可以用反射來了解自己的類及各種元素上有無何種標記，有

類載入器 - 類的載入、連線與初始化

類的載入、連線與初始化 概述 在Java程式碼中，型別的載入、連線與初始化過程都是在程式執行期間完成的 型別：可以理解為一個class 載入：查詢並載入類的二進位制資料，最常見的情況是將已經編譯完成的類的class檔案從磁碟載入到記憶體中 連線：確定型別與型別之間的關係，對於位元組碼的相關處理 驗證：確保

類檔案的結構、JVM 的類載入過程、類載入機制、類載入器、雙親委派模型

# 一、類檔案的結構 我們都知道，各種不同平臺的虛擬機器，都支援 “位元組碼 Byte Code” 這種程式儲存格式，這構成了 Java 平臺無關性的基石。甚至現在平臺無關性也開始演變出 “語言無關性” ，就是其他語言也可以執行在 Java 虛擬機器之上，比如現在的 Kotlin、Scala 等。

Regularized least-squares classification（正則化最小二乘法分類器）取代SVM

得出 ack 提高 kernel sys 風險 重要 ref height 在機器學習或者是模式識別其中有一種重要的分類器叫做：SVM 。這個被廣泛的應用於各個領域。可是其計算的復雜度以及訓練的速度是制約其在實時的計算機應用的主要原因。因此也非常非常多的算法

Java程式設計師從笨鳥到菜鳥之（九十三）深入java虛擬機器（二）——類載入器詳解（上）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

深入淺出JVM（jvm記憶體結構，類載入器圖，雙親委託模式，堆記憶體，GC解析，GC演算法）

目錄 Java虛擬機器的記憶體結構：  類載入器圖： 雙親委託模式： 堆記憶體： GC解析圖： GC演算法 Java虛擬機器的記憶體結構：  類載入器圖：   雙親委託模式： Java允許建立和JDK自帶類

架構探險（三）自定義類載入器

今天我們來談一談架構探險中自定義的類載入器，一般我們若想實現自定義的類載入器，可以繼承ClassLoader類，然後實現findClass方法即可，詳細介紹可以看以下連結： https://www.cnblogs.com/doit8791/p/5820037.html 本文

JVM類載入器與雙親委派模型（二）

（7）URLClassLoader類 前面說到，ClassLoader這個頂級父類只是定義好了雙親委派模型的工作機制；但是ClassLoader是個抽象類，無法直接建立物件，所以需要由繼承它的子類完成建立物件的任務。子類需要自己實現findClass方法，並且在例項化時指定parent屬性的值

JVM類載入器與雙親委派模型（一）

（1）動態載入       類載入器是 Java 語言的一個創新，也是 Java 語言流行的重要原因之一。它使得 Java 類可以被動態載入到 Java 虛擬機器中並執行。類載入器從 JDK 1.0 就出現了，最初是為了滿足 Java Applet 的需要

python3之裝飾器（類裝飾器）實現 下篇

上篇中我們介紹了閉包的用法，同時利用裝飾器實現了為函式新增返回原始資料的功能，那麼它怎麼實現的呢，讓我們揭開它神祕的面紗。 def decorator(f): def wrapper(x,y): print("引數1為:%s,引數2為:%