獲取父類的泛型

java反射概述

java Reflection，java中的反射（Reflection）被認為是動態語言的關鍵，反射機制允許程式在執行期藉助Reflection API取得任何類的內部資訊。並且能直接操作任意物件的內部屬性和方法。

簡單來說，反射就是載入類，並解剖出類的各個組成部分。

java反射機制提供的功能：

在執行時判斷任意一個物件所屬的類
在執行時構造任意一個類的物件
在執行時判斷任意一個類所具有的成員變數和方法
在執行時呼叫任意一個物件的成員變數和方法 生成動態代理

與java反射相關的類：

java.lang.Class: 一個例項代表了一個執行時類
java.lang.reflect.Method:代表類的方法
java.lang.reflect.Field:代表類的成員變數
java.lang.reflect.Constructor:代表類的構造方法

我們知道java的基類是Object類，其以下方法：

public final Class getClass() 方法返回值的型別是一個Class類，值是當前物件的類(如Person.class)，而此時的這個類作為Class類的一個例項。

Class類是Java反射的源頭，實際上所謂反射從程式的執行結果來看也很好理解，即：可以通過物件反射求出類的名稱。

正常情況下例項化物件的過程如下:

通過 類，new例項化物件。

反射機制通過 當前物件，getClass()方法返回當前物件的類。

Class類

通過反射可以得到的資訊：某個類的屬性、方法和構造器、某個類到底實現了哪些介面，方法的返回值型別，等等資訊。

對於每個類而言，JRE 都為其保留一個不變的 Class 型別的物件。一個 Class 物件包含了特定某個類的有關資訊。

1，Class本身也是一個類
2，Class 物件只能由系統建立物件(jvm)
3，一個類在 JVM 中只會有一個Class例項
4，一個Class物件對應的是一個載入到JVM中的一個.class檔案
5，每個類的例項都會記得自己是由哪個 Class 例項所生成
6，通過Class可以完整地得到一個類中的完整結構
理解： * java程式經過javac.exe命令後，會生成一個或多個.class位元組碼檔案.接著使用java.exe命令，呼叫JVM的類的載入器

• 將位元組碼檔案載入到記憶體中（存放在快取區），一個位元組碼檔案就對應著一個執行時類。這個載入到記憶體中的執行時類本身就充當了Class的一個例項。

• 一個Class的例項就對應著一個執行時類

• 執行時類只會在記憶體中載入一次。

Class類的常用方法：

Class 沒有公共構造方法。Class 物件是在載入類時由 Java 虛擬機器以及通過呼叫類載入器中的 defineClass 方法自動構造的。

static Class forName(String name) 返回指定型別name的Class物件，name是包含限定名的類，例如：”java.lang.Object”

Object newInstance();呼叫預設無參構造器，返回Class物件的一個例項

String getName() 返回此Class物件所表示的實體（類、介面、陣列類、基本型別 或void）名稱,

Class getSuperClass()返回當前Class物件的父類的Class物件

Class[] getInterface()獲取當前Class物件的介面

ClassLoader getClassLoader()返回該類的類載入器

Class getSuperClass()返回表示此Class例項的超類的Class 物件

Constructor[] getDeclaredConstructors()返回一個含Constructor物件的陣列 Field[] getDeclaredFields()返回Field物件的一個數組

Method getMethod(String name,Class…paramType) 返回一個Method物件，此物件的形參型別為Class paramType

獲取Class類物件的幾種方法

1）前提：若已知具體的類，通過類的class屬性獲取，該方法最為安全可靠，程式效能最高

例項：Class clazz = String.class;dd//String的class屬性
2）前提：已知某個類的例項，呼叫該例項的getClass()方法獲取Class物件
例項：Class clazz =new Person().getClass();
3）前提：已知一個類的全類名，且該類在類路徑下，可通過Class類的靜態方法forName()獲取，可能丟擲ClassNotFoundException例項：Class clazz = Class.forName(“java.lang.String”);
4）其他方式//通過當前類的類載入器

ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“全類名”);
示例分析：

通過Class類的靜態方法forName(“全類名”）獲取其例項

Class clazz = Class.forName(“com.atguigu.exer.Person”);

通過Class物件的getDeclaredMethod(“方法名”，Class型別的形參)方法，獲取Class物件的方法。

Method eat = clazz.getDeclaredMethod(“eat”, String.class);

物件方法呼叫setAccessible()方法設定當前物件（ ）的可訪問許可權·· eat.setAccessible(true);

通過Class物件建立其型別的物件

Person p1 = (Person)clazz.newInstance();

物件方法呼叫invoke（Object 物件， 實參），並將該方法的返回結果以Object物件的形式返回；

若是靜態方法或者靜態屬性可以使用類名.class的形式代替類的例項。

Object result = eat.invoke(p1, “apple”);

Field nation = clazz.getDeclaredField(“nation”);

nation.setAccessible(true);

nation.set(Person.class, “china”);

Object nationValue = nation.get(Person.class);

System.out.println(nationValue);

Constructor con =

clazz.getDeclaredConstructor(String.class,Integer.class,String.class);

con.setAccessible(true);

Object object = con.newInstance(“tom”,23,”China”);

System.out.println(object);

//注意的情況，int對應的class類為int.class,不能使用Integer.class.

獲取父類的泛型：

Class clazz = Person.class;

Type gen = clazz.getGenericSuperclass();

ParameterizedType gensup = (ParameterizedType) gen;

Type[] type = gensup.getActualTypeArguments();

System.out.println(((Class)type[0]).getName());

類載入的過程：

當程式主動使用某一個類的時候，若該類還沒有載入到記憶體中，則系統會通過如下方式首次載入該類，並進行初始化。

1，將類的class檔案讀入到記憶體中，並自動為之建立一個java.lang.Class類的物件。此過程由類的載入器完成。【類檔案的載入】

2，將類的二進位制資料合併到JRE中。【類資料的連線】

3，JVM負責將類進行初始化。

類載入器的瞭解：

類載入器（ClassLoader）是用來把類(class)裝載進記憶體的。JVM 規範定義了兩種型別的類載入器：啟動類載入器(bootstrap)和使用者自定義載入器(user-defined class loader)。

JVM在執行時會產生3個類載入器組成的初始化載入器層次結構如下：

引導類載入器（Bootstap Classloader）：用C++編寫的，是JVM自帶的類裝載器，負責Java平臺核心庫，用來裝載核心類庫。該載入器無法直接獲取。

擴充套件類載入器（Extension ClassLoader）：負責jre/lib/ext目錄下的jar包或 –d java.ext.dirs 指定目錄下的jar包裝入工作庫

系統類載入器（System ClassLoader）：負責java –classpath 或 –D java.class.path所指的目錄下的類與jar包裝入工作 ，是最常用的載入器。

//1.獲取一個系統類載入器ClassLoader classloader = ClassLoader.getSystemClassLoader();

//2.獲取系統類載入器的父類載入器，即擴充套件類載入器classloader = classloader.getParent();

//3.獲取擴充套件類載入器的父類載入器，即引導類載入器classloader = classloader.getParent();

獲取當前類的載入器（主要通過Class物件的getClassLoader()方法獲取）

ClassLoader classloader =

Class.forName(“com.atguigu.reflection.Customer”).getClassLoader();

關於類載入器的一個主要方法：
getResourceAsStream(String str):獲取當前類路徑下的指定檔案的輸入流
InputStream in = null;
in= this.getClass().getClassLoader().getResourceAsStream(“com\atguigu\reflection.properties”);

Properties pro = new Properties();

pro.load(is);

String user = pro.getProperty(“user”);

String pwd = pro.getProperty(“pwd”);
//properties檔案位於當前包路徑下

通過Class類物件能夠做些什麼？

建立類的物件：呼叫Class物件的newInstance()方法要求

1）類必須有一個無引數的構造器。
2）類的構造器的訪問許可權需要足夠。

難道沒有無參的構造器就不能建立物件了嗎？ 在操作的時候明確的呼叫類中的構造方法，並將引數傳遞進去之後，才可以例項化操作。步驟如下：
1）通過Class類的getDeclaredConstructor(Class … parameterTypes)取得本類的指定形參型別的構造器
2）向構造器的形參中傳遞一個物件陣列進去，裡面包含了構造器中所需的各個引數。
3）通過Constructor例項化物件。

示例：

//1.根據全類名獲取對應的Class物件
String name = “atguigu.java.Person”;
Class clazz = null;
clazz = Class.forName(name);

//2.呼叫指定引數結構的構造器，生成Constructor的例項
Constructor con = clazz.getConstructor(String.class,Integer.class);

//3.通過Constructor的例項建立對應類的物件，並初始化類屬性

Person p2 = (Person) con.newInstance(“Peter”,20);System.out.println(p2);

動態代理：

原理： 首先定義一個共同的介面，被代理類實現該介面， 使用一個代理類同樣實現該介面，並將被代理類的物件聚合到代理類中， 然後用該代理物件取代被代理物件. 任何對（被代理）原始物件的呼叫都要通過代理. 代理物件決定是否以及何時將方法呼叫轉到原始物件上。

java實現動態代理的類proxy：

Proxy ：專門完成代理的操作類，是所有動態代理類的父類。
通過此類為一個或多個介面動態地生成實現類。 提供用於建立動態代理類和動態代理物件的靜態方法：
Class

//1定義介面

interface ManFunction{

String info(String string);

void fly();

}

//2實現被代理類

class Man implements ManFunction{

@Override

public String info(String str) {

return str;

}

@Override

public void fly() {

System.out.println("i can fly, you can?");

}

}

//3代理類實現 被代理 的介面

class MyHandler implements InvocationHandler{

Object obj;

public MyHandler(Object obj) {

this.obj = obj;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

return method.invoke(obj, args);

}

}

//4建立動態代理類

class ProxyObject {

public static Object getInstanceObject(Object obj){

MyHandler in = new MyHandler(obj);

Object newProxyInstance =
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), in);

return newProxyInstance;

}

}

在測試類中注意的問題：
1，建立被代理類物件
2，動態代理類建立動態代理，由於生成的動態代理也實現了該介面，故而可以將其轉換為該介面型別，進而呼叫介面中的方法（也就是被代理類的方法）。

反射補充：

在呼叫反射到類的方法中引數是陣列的情況下，例如main（String[] args),由於java1.5版本才有了可變形參，而又要相容java1.4，故而java1.5之後反射到類的方法中有陣列形參時，都會預設將陣列拆開。例如：故而需要將陣列行參用object型別包裝。

在反射到某一個類的main(String [] args)方法，而又要呼叫這個方法。

Method method = clazz.getMethod(“main”,String[].class);

method.invoke(Person .class, new String[] ( “aa” ,”bb”)); 非法引數異常；

method.invoke(null, new Object[] {new String [] {” aa”, “bb”}});

或者

method.invoke(null,(Object ) new String[] {“aa”,”bb”});

反省introspector

javaBean,操作的欄位都稱為屬性

一個get或者set方法就稱為一個屬性。

使用內省introspector API 操作 bean的屬性。