1. 注解
- 注解入門
- Annotation 是 JDK 5 開(kāi)始引入的新技術(shù)嗓袱。
- Annotation 的作用：
- 不是程序本身，可以對(duì)程序作出解釋胸蛛，這一點(diǎn)和注釋（comment）沒(méi)什么區(qū)別污茵；
- 可以被其他程序（例如編譯器）讀取。
- Annotation 的格式
- 注解是以 “@注釋名” 在代碼中存在葬项，也可以帶參數(shù)泞当，例如：@SuppressWarnings(value="unchcked")
- Annotation 在哪里使用？
- 可以附加在 package民珍、class襟士、method、field 上嚷量，相當(dāng)于給它們添加了額外的輔助信息陋桂，還可以通過(guò)反射機(jī)制，編程實(shí)現(xiàn)對(duì)這些元數(shù)據(jù)的訪問(wèn)津肛。
package com.xxx.annotation.demo01;
/**
* 注解
*/
public class Test01 extends Object{
// @Override 重寫的注解
@Override
public String toString() {
return super.toString();
}
}
- 內(nèi)置注解
-
@Override（重寫）：定義在
java.lang.Override中章喉，此注釋只適用于修辭方法，表示一個(gè)方法身坐，聲明重寫超類中的另一個(gè)方法聲明。 -
@Deprecated（過(guò)時(shí)）：定義在
java.lang.Deprecated中落包，此注釋可以用于修辭方法部蛇，屬性，類咐蝇，表示不鼓勵(lì)程序員使用這樣的元素涯鲁，通常，是因?yàn)樗芪ｋU(xiǎn)有序，或者存在更好的選擇抹腿。 -
@SuppressWarnings（鎮(zhèn)壓警告）：定義在
java.lang.SuppressWarnings中，用來(lái)抑制編譯時(shí)的警告信息旭寿。- 與前兩個(gè)注釋有所不同警绩，需要添加一個(gè)參數(shù)才能正確使用，這些參數(shù)都是已經(jīng)定義好了的盅称，選擇性的使用就好了肩祥。
- @SuppressWarnings("all")
- @SuppressWarnings("unchecked")
- @SuppressWarnings(value={"unchecked"后室，"deprecation"})
- 等等……
package com.xxx.annotation.demo01;
/**
* 注解
*/
public class Test01 extends Object {
// Override 重寫的注解
@Override
public String toString() {
return super.toString();
}
// @Deprecated 不推薦使用，但可以使用混狠，或者存在更好的更新方式
@Deprecated
public static void test() {
System.out.println("Deprecated");
}
// @SuppressWarnings 鎮(zhèn)壓警告
@SuppressWarnings("all")
public void test01() {
List<String> list = new ArrayList<>();
}
public static void main(String[] args) {
test();
}
}
- 元注解
- 元注解的作用岸霹，就是負(fù)責(zé)注解其他注解，Java 定義了 4 個(gè)標(biāo)準(zhǔn)的
meta- annotation類型将饺，他們被用來(lái)提供對(duì)其他annotation類型作說(shuō)明贡避。 - 這些類型和它們所支持的類，在
java.lang.annotation包中可以找到予弧。（@Target刮吧，@Retention，@Documented桌肴，@Inherited）- @Target：用于描述注解的使用范圍（即：被描述的注解可以用在什么地方）皇筛。
-
@Retention：表示需要在什么級(jí)別保存該注釋信息，用于描述注解的生命周期坠七。
- (SOURCE < CLASS < RUNTIME)
- @Document：說(shuō)明該注解將被包含在 javadoc 中水醋。
- @Inherited：說(shuō)明子類可以 繼承父類 中的該注解。
package com.xxx.annotation.demo01;
import java.lang.annotation.*;
/**
* 元注解
*/
public class Test02 {
public void test() {
}
}
// 定義一個(gè)注解
// @Target 注解可以用在什么地方
// ElementType.METHOD 方法上有效 ElementType.TYPE類上有效
@Target(value = {ElementType.METHOD, ElementType.TYPE})
// @Retention 在什么地方有效
// RUNTIME > CLASS > SOURCES
@Retention(value = RetentionPolicy.RUNTIME)
// @Documented 表示是否將我們的注解生成在Javadoc中
@Documented
// @Inherited 子類可以繼承父類的注解
@Inherited
@interface Myannotation {
}
- 自定義注解
- 使用 @interface 自定義注解時(shí)彪置，自動(dòng)繼承了
java.lang.annotation. Annotation接口拄踪。 - 分析：
- @interface 用來(lái)聲明一個(gè)注解，格式：
public @interface 注解名{ 定義內(nèi)容 } - 其中的每一個(gè)方法拳魁，實(shí)際上是聲明了一個(gè)配置參數(shù)惶桐；
- 方法的名稱就是參數(shù)的名稱。
- 返回值類型就是參數(shù)的類型（返回值只能是基本類型：Class潘懊、String姚糊、enum）
- 可以通過(guò) default 來(lái)聲明參數(shù)的默認(rèn)值；
- 如果只有一個(gè)參數(shù)成員授舟，一般參數(shù)名為 value救恨；
- 注解元素必須要有值，我們定義注解元素時(shí)释树，經(jīng)常使用空字符串肠槽，0 作為默認(rèn)值。
- @interface 用來(lái)聲明一個(gè)注解，格式：
package com.xxx.annotation.demo01;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定義注解
*/
public class Test03 {
// 注解可以顯示賦值,如果沒(méi)有默認(rèn)值,就必須給注解賦值
@Myannotation2(age = 20, name = "Liu")
public void test() {
}
// 注解只有一個(gè)參數(shù) value 時(shí)奢啥，使用時(shí)可省略 value
@Myannotation3("test")
public void test2() {
}
}
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotation2 {
// 注解的參數(shù)：參數(shù)類型 + 參數(shù)名（）
String name() default "";
int age();
int id() default -1; // 如果默認(rèn)為 -1秸仙，代表不存在
String[] schools() default {"school1", "school2"};
}
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotation3 {
// 一個(gè)參數(shù)時(shí)，建議使用 value
String value();
}
2. 反射機(jī)制
1. Java反射機(jī)制概念
- 靜態(tài) & 動(dòng)態(tài)語(yǔ)言
- 動(dòng)態(tài)語(yǔ)言
- 是一類在運(yùn)行時(shí)桩盲，可以改變其結(jié)構(gòu)的語(yǔ)言秘血，例如：新的函數(shù)防症、對(duì)象劈伴、甚至代碼，可以被引進(jìn)抢腐，已有的函數(shù)可以被刪除，或是其他結(jié)構(gòu)上的變化襟交。通俗點(diǎn)說(shuō)就是在運(yùn)行時(shí)迈倍，代碼可以根據(jù)某些條件，改變自身結(jié)構(gòu)捣域。
- 主要?jiǎng)討B(tài)語(yǔ)言：Object-C啼染、C#、JavaScript焕梅、PHP迹鹅、Python等。
- 靜態(tài)語(yǔ)言
- 與動(dòng)態(tài)語(yǔ)言相對(duì)應(yīng)的贞言，運(yùn)行時(shí)結(jié)構(gòu)不可變的語(yǔ)言斜棚，就是靜態(tài)語(yǔ)言。如 Java该窗、C弟蚀、C++。
- Java 不是動(dòng)態(tài)語(yǔ)言酗失，但 Java 可以稱之為 “準(zhǔn)動(dòng)態(tài)語(yǔ)言”义钉。即 Java有一定的動(dòng)態(tài)性，可以利用反射機(jī)制规肴，獲得類似動(dòng)態(tài)語(yǔ)言的特性捶闸。Java 的動(dòng)態(tài)性，讓編程的時(shí)候更加靈活拖刃。
- 反射機(jī)制概念
- Reflection（反射）是 Java 被視為動(dòng)態(tài)語(yǔ)言的關(guān)鍵删壮，反射機(jī)制允許程序在執(zhí)行期，借助于 Reflection API 取得仼何類的內(nèi)部信息兑牡，并能直接操作任意對(duì)象的內(nèi)部屬性及方法醉锅。
Class c= Class.forName("java.lang.String");
- 加載完類之后，在堆內(nèi)存的方法區(qū)中发绢，就產(chǎn)生了一個(gè) Class 類型的對(duì)象（一個(gè)類只有一個(gè) Class 對(duì)象），這個(gè)對(duì)象就包含了垄琐，完整的類的結(jié)構(gòu)信息边酒。可以通過(guò)這個(gè)對(duì)象狸窘，看到類的結(jié)構(gòu)墩朦。這個(gè)對(duì)象就像一面鏡子，透過(guò)這個(gè)鏡子翻擒，看到類的結(jié)構(gòu)氓涣，所以牛哺，形象的稱之為：反射。
- 反射機(jī)制研究與應(yīng)用
- Java 反射機(jī)制提供的功能
- 在運(yùn)行時(shí)劳吠，判斷任意一個(gè)對(duì)象所屬的類引润；
- 在運(yùn)行時(shí)，構(gòu)造任意一個(gè)類的對(duì)象痒玩；
- 在運(yùn)行時(shí)淳附，判斷任意一個(gè)類所具有的成員變量和方法；
- 在運(yùn)行時(shí)蠢古，獲取泛型信息奴曙；
- 在運(yùn)行時(shí)，調(diào)用任意一個(gè)對(duì)象的成員變量和方法草讶；
- 在運(yùn)行時(shí)洽糟，處理注解；
- 生成動(dòng)態(tài)代理堕战；
- ……
- 反射機(jī)制的優(yōu)缺點(diǎn)
- 優(yōu)點(diǎn)：
- 可以實(shí)現(xiàn)動(dòng)態(tài)創(chuàng)建對(duì)象和編譯坤溃，體現(xiàn)出很大的靈活性。
- 缺點(diǎn)
- 對(duì)性能有影響践啄。使用反射基本上是一種解釋操作浇雹，可以告訴 JVM屿讽，希望做什么昭灵，并且滿足要求。這類操作總是慢于伐谈，直接執(zhí)行相同的操作烂完。
- 實(shí)例：
package com.xxx.reflection;
/**
* 反射
*/
public class Test01 {
public static void main(String[] args) throws ClassNotFoundException {
// 通過(guò)反射獲取類的 Class 對(duì)象，需要捕獲異常
Class c1 = Class.forName("com.xxx.reflection.User");
System.out.println(c1);
// 創(chuàng)建的多個(gè)對(duì)象诵棵，實(shí)際上是同一對(duì)象
Class c2 = Class.forName("com.xxx.reflection.User");
Class c3 = Class.forName("com.xxx.reflection.User");
Class c4 = Class.forName("com.xxx.reflection.User");
// 一個(gè)類在內(nèi)存中只有一個(gè) Class 對(duì)象
// 一個(gè)類被加載后,類的整個(gè)結(jié)構(gòu)都會(huì)被封裝在 Class 對(duì)象中
// public native int hashCode();返回該對(duì)象的 hash 碼值
// 注：哈希值是根據(jù)哈希算法算出來(lái)的一個(gè)值抠蚣，這個(gè)值跟地址值有關(guān)，但不是實(shí)際地址值履澳。
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4.hashCode());
}
}
// 實(shí)例類：pojo entity
class User {
private String name;
private int id;
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", id=" + id +
", age=" + age +
'}';
}
}
2. 理解 Class 類并獲取 Class 實(shí)例
- class 類介紹
- 在 Object 類中定義了以下的方法嘶窄，此方法將被所有子類繼承；
public final Class getclass();
- 以上方法返回值的類型距贷，是一個(gè) Class 類柄冲，此類是 Java 反射的源頭，實(shí)際上忠蝗，所謂反射现横，從程序的運(yùn)行結(jié)果來(lái)看，也很好理解，即：可以 通過(guò)對(duì)象反射求出類的名稱戒祠。
- 對(duì)象照鏡子后骇两，可以得到的信息：某個(gè)類的屬性姜盈、方法和構(gòu)造器低千、某個(gè)類到底實(shí)現(xiàn)了哪些接口，對(duì)于每個(gè)類而言贩据，JRE 都為其保留一個(gè)不變的 Class 類型的對(duì)象栋操。一個(gè) Class 對(duì)象，包含了特定某個(gè)結(jié)構(gòu)（
class/interface/enum/annotation/primitive type/void/[]）的有關(guān)信息饱亮。- Class 本身也是一個(gè)類矾芙；
- Class 對(duì)象只能由系統(tǒng)建立對(duì)象；
- 一個(gè)加載的類在 JVM 中近上，只會(huì)有一個(gè) Class 實(shí)例剔宪；
- 一個(gè) Class 對(duì)象，對(duì)應(yīng)的是一個(gè)加載到 JVM 中的一個(gè) .class 文件壹无；
- 每個(gè)類的實(shí)例葱绒，都會(huì)記得自己是由哪個(gè) Class 實(shí)例所生成；
- 通過(guò) Class斗锭，可以完整地得到地淀，一個(gè)類中的所有被加載的結(jié)構(gòu)；
- Class 類是 Reflection 的根源岖是，針對(duì)任何想動(dòng)態(tài)加載帮毁、運(yùn)行的類，唯有先獲得相應(yīng)的 Class 對(duì)象豺撑。
- class類的常用方法
| 方法名 | 功能說(shuō)明 |
|---|---|
| static ClassforName(String name) | 返回指定類名 name 的 Class 對(duì)象 |
| Object newInstance() | 調(diào)用缺省構(gòu)造函數(shù)烈疚，返回 Class 對(duì)象的一個(gè)實(shí)例 |
| getName() | 返回此 Class 對(duì)象所表示的實(shí)體（類，接口聪轿，數(shù)組類或 void）的名稱爷肝。 |
| Class getSuperClass() | 返回當(dāng)前class對(duì)象的父類的class對(duì)象 |
| Class[] getinterfaces() | 獲取當(dāng)前 Class 對(duì)象的接口 |
| ClassLoader getclassLoader() | 返回該類的類加載器 |
| Constructor[] getConstructors() | 返回一個(gè)包含某些 Constructor 對(duì)象的數(shù)組 |
| Method getMothed(String name, Class…T) | 返回一個(gè) Method 對(duì)象，此對(duì)象的形參類型為 paramType |
| Field[] getDeclaredFields() | 返回 Field 對(duì)象的一個(gè)數(shù)組 |
- 獲取 Class 類的實(shí)例
- 若已知具體的類陆错，通過(guò)類的 class 屬性獲取灯抛，該方法最為安全可靠，程序性能最高音瓷。
Class clazz = Person.class;
- 已知某個(gè)類的實(shí)例牧愁，調(diào)用該實(shí)例的 getClass() 方法獲取 Class 對(duì)象。
Class clazz = person.getClass();
- 已知一個(gè)類的全類名外莲，且該類在類路徑下，可通過(guò) Class 類的靜態(tài)方法 forName() 獲取，可能拋出 ClassNotFound Exception偷线。
Class clazz = Class forName("demo01.Student");
- 內(nèi)置基本數(shù)據(jù)類型磨确，可以直接用
類名.Type。 - 還可以利用 ClassLoader声邦。
- 實(shí)例：
package com.xxx.reflection;
/**
* Class 類的創(chuàng)建方式
*/
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("這個(gè)人是：" + person.name);
// 方式1：通過(guò)對(duì)象獲得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
// 方式2：forName 獲得
Class c2 = Class.forName("com.xxx.reflection.Student");
System.out.println(c2.hashCode());
// 方式3：類名.class 獲得
Class c3 = Student.class;
System.out.println(c3.hashCode());
// 方式4：基本類型的包裝類都有一個(gè) Type 屬性
Class c4 = Integer.TYPE;
System.out.println(c4);
// 方式5：獲得父類類型
Class c5 = c1.getSuperclass();
System.out.println(c5);
}
}
class Person {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person {
public Student() {
this.name = "學(xué)生";
}
}
class Teacher extends Person {
public Teacher() {
this.name = "老師";
}
}
- 哪些類型可以有 Class 對(duì)象
- class：外部類乏奥，成員（成員內(nèi)部類，靜態(tài)內(nèi)部類）亥曹，局部?jī)?nèi)部類邓了，匿名內(nèi)部類。
- interface：接口
- []：數(shù)組
- enum：枚舉
- annotation：注解@interface
- primitive type：基本數(shù)據(jù)類型
- void
- 實(shí)例：
package com.xxx.reflection;
import java.lang.annotation.ElementType;
/**
* 所有類型的 Class
*/
public class Test03 {
public static void main(String[] args) {
Class c1 = Object.class; // 類
Class c2 = Comparable.class; // 接口
Class c3 = String[].class; // 一維數(shù)組
Class c4 = int[][].class; // 二維數(shù)組
Class c5 = Override.class; // 注解
Class c6 = ElementType.class; // 枚舉
Class c7 = Integer.class; // 基本數(shù)據(jù)類型
Class c8 = void.class; // void
Class c9 = Class.class; // class
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
// 只要元素類型與維度一樣,就是同一個(gè)Class
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}
3. 類的加載與 ClassLoader
- Java 內(nèi)存分析
- 類的加載
- 當(dāng)程序主動(dòng)使用某個(gè)類時(shí)媳瞪，如果該類還未被加載到內(nèi)存中骗炉，則系統(tǒng)會(huì)通過(guò)如下三個(gè)步驟，來(lái)對(duì)該類進(jìn)行初始化蛇受。
-
加載：將 class 文件字節(jié)碼內(nèi)容句葵，加載到內(nèi)存中，并將這些靜態(tài)數(shù)據(jù)兢仰，轉(zhuǎn)換成方法區(qū)的運(yùn)行時(shí)數(shù)據(jù)結(jié)構(gòu)乍丈，然后生成一個(gè)代表這個(gè)類的
java.lang.Class對(duì)象。 -
鏈接：將 Java 類的二進(jìn)制代碼把将，合并到 JVM 的運(yùn)行狀態(tài)之中的過(guò)程轻专。
- 驗(yàn)證：確保加載的類信息符合 JVM 規(guī)范，沒(méi)有安全方面的問(wèn)題察蹲。
- 準(zhǔn)備：正式為類變量（ static）分配內(nèi)存请垛，并設(shè)置類變量默認(rèn)初始值的階段，這些內(nèi)存都將在方法區(qū)中進(jìn)行分配递览。
- 解析：虛擬機(jī)常量池內(nèi)的符號(hào)引用（常量名）叼屠，替換為直接引用（地址）的過(guò)程。
- 初始化：
- 執(zhí)行類構(gòu)造器 <clinit>() 方法的過(guò)程绞铃。類構(gòu)造器 <clinit>() 方法镜雨，是由編譯器，自動(dòng)收集類中儿捧，所有類變量的賦值動(dòng)作荚坞，和靜態(tài)代碼塊中的語(yǔ)句合并產(chǎn)生的。（類構(gòu)造器是構(gòu)造類信息的菲盾，不是構(gòu)造該類對(duì)象的構(gòu)造器）颓影。
- 當(dāng)初始化一個(gè)類的時(shí)候，如果發(fā)現(xiàn)其父類懒鉴，還沒(méi)有進(jìn)行初始化诡挂，則需要碎浇，先觸發(fā)其父類的初始化。
- 虛擬機(jī)璃俗，會(huì)保證一個(gè)類的 <clinit>() 方法奴璃，在多線程環(huán)境中，被正確加鎖和同步城豁。
- 深刻理解類加載
package com.xxx.reflection;
/**
* 類加載
*/
public class Test04 {
public static void main(String[] args) {
A a = new A();
System.out.println(A.m);
/*
1. 加載到內(nèi)存,會(huì)產(chǎn)生一個(gè)類對(duì)應(yīng) Class 對(duì)象
2. 鏈接,連接結(jié)束后 m=0
3. 初始化
<clinit>(){
System.out.println("A類靜態(tài)代碼塊初始化");
m = 300;
m = 100;
}
*/
}
}
class A {
static {
System.out.println("A類靜態(tài)代碼塊初始化");
m = 300;
}
static int m = 100;
public A() {
System.out.println("A類的無(wú)參構(gòu)造初始化");
}
}
- 什么時(shí)候會(huì)發(fā)生類初始化
-
類的主動(dòng)引用（一定會(huì)發(fā)生類的初始化）
- 當(dāng)虛擬機(jī)啟動(dòng)苟穆，先初始化 main 方法所在的類；
- new 一個(gè)類的對(duì)象唱星；
- 調(diào)用類的靜態(tài)成員（除了 final 常量）和靜態(tài)方法雳旅；
- 使用
java.lang.reflect包的方法對(duì)類進(jìn)行反射調(diào)用； - 當(dāng)初始化一個(gè)類间聊，如果其父類沒(méi)有被初始化攒盈，則先會(huì)初始化它的父類。
-
類的被動(dòng)引用（不會(huì)發(fā)生類的初始化）
- 當(dāng)訪問(wèn)一個(gè)靜態(tài)域時(shí)甸饱，只有真正聲明這個(gè)域的類沦童，才會(huì)被初始化。如：當(dāng)通過(guò)子類引用父類的靜態(tài)變量叹话，不會(huì)導(dǎo)致子類初始化偷遗；
- 通過(guò)數(shù)組定義類引用，不會(huì)觸發(fā)此類的初始化驼壶；
- 引用常量不會(huì)觸發(fā)此類的初始化（常量在鏈接階段氏豌，就存入調(diào)用類的常量池中了）。
- 實(shí)例：測(cè)試類的初始化
package com.xxx.reflection;
/**
* 測(cè)試類的初始化
*/
public class Test05 {
static {
System.out.println("Main類被加載热凹！");
}
public static void main(String[] args) throws ClassNotFoundException {
// 一泵喘、會(huì)產(chǎn)生類的初始化（主動(dòng)引用）
// 1.創(chuàng)建類對(duì)象
Son son = new Son();
// 2.反射也會(huì)產(chǎn)生主動(dòng)引用
Class.forName("com.xxx.reflection.Son");
// 二、不會(huì)產(chǎn)生類的引用的方法（被動(dòng)引用）
// 1.子類引用父類的靜態(tài)變量般妙，不會(huì)導(dǎo)致子類初始化
System.out.println(Son.b);
// 2.定義數(shù)組
Son[] array = new Son[5];
// 3.引用常量
System.out.println(Son.M);
}
}
class Father {
static final int b = 2;
static {
System.out.println("父類被加載");
}
}
class Son extends Father {
static {
System.out.println("子類被加載");
m = 300;
}
static int m = 100;
static final int M = 1;
}
- 類加載器的作用
- 類加載的作用：將 class 文件字節(jié)碼內(nèi)容加載到內(nèi)存中纪铺，并將這些靜態(tài)數(shù)據(jù)，轉(zhuǎn)換成方法區(qū)的運(yùn)行時(shí)數(shù)據(jù)結(jié)構(gòu)碟渺，然后在堆中生成一個(gè)鲜锚，代表這個(gè)類的
java.lang.Class對(duì)象，作為方法區(qū)中類數(shù)據(jù)的訪問(wèn)入口苫拍。 - 類緩存：標(biāo)準(zhǔn)的 JavaSE 類加載器芜繁，可以按要求查找類，一旦某個(gè)類绒极，被加載到類加載器中骏令，它將維持加載（緩存）一段時(shí)間。不過(guò) JVM 垃圾回收機(jī)制垄提，可以回收這些 Class 對(duì)象榔袋。
- 類加載器作用：是用來(lái)把類（class）裝載進(jìn)內(nèi)存的周拐。JVM 規(guī)范定義了如下類型的類的加載器。
- 獲取系統(tǒng)類的加載器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
- 獲取系統(tǒng)類加載器的父類加載器–> 擴(kuò)展類加載器 jre1.8.0_91\lib\ext
ClassLoader parent = systemClassLoader.getParent();
- 獲取擴(kuò)展類加載器父類加載器–> 根加載器(c/c++) jre1.8.0_91\lib\rt.jar
ClassLoader parent1 = parent.getParent();
- 實(shí)例：類加載器
package github.Annotation.Demo02;
/**
* 類加載器
*/
public class TestClassLoader1 {
public static void main(String[] args) throws ClassNotFoundException {
// 獲取系統(tǒng)類的加載器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
// 獲取系統(tǒng)類加載器的父類加載器-->擴(kuò)展類加載器 jre1.8.0_91\lib\ext
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
// 獲取擴(kuò)展類加載器父類加載器-->根加載器(c/c++) jre1.8.0_91\lib\rt.jar
ClassLoader parent1 = parent.getParent();
System.out.println(parent1);
// 測(cè)試當(dāng)前類是哪個(gè)加載器加載的
ClassLoader classLoader = Class.forName("github.Annotation.Demo02.TestClassLoader1").getClassLoader();
System.out.println(classLoader);
// 測(cè)試JDK內(nèi)置的類是誰(shuí)加載的
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader);
// 如何獲得系統(tǒng)類加載器可以加載的路徑
System.out.println(System.getProperty("java.class.path"));
// 雙親委派機(jī)制 檢測(cè)安全性 你寫的類和跟加載器一樣的不會(huì)用你寫的類
// java.lang.String -->往上推
/*
F:\java\JDK\jre\lib\charsets.jar;
F:\java\JDK\jre\lib\deploy.jar;
F:\java\JDK\jre\lib\ext\access-bridge-64.jar;
F:\java\JDK\jre\lib\ext\cldrdata.jar;
F:\java\JDK\jre\lib\ext\dnsns.jar;
F:\java\JDK\jre\lib\ext\jaccess.jar;
F:\java\JDK\jre\lib\ext\jfxrt.jar;
F:\java\JDK\jre\lib\ext\localedata.jar;
F:\java\JDK\jre\lib\ext\nashorn.jar;
F:\java\JDK\jre\lib\ext\sunec.jar;
F:\java\JDK\jre\lib\ext\sunjce_provider.jar;
F:\java\JDK\jre\lib\ext\sunmscapi.jar;
F:\java\JDK\jre\lib\ext\sunpkcs11.jar;
F:\java\JDK\jre\lib\ext\zipfs.jar;
F:\java\JDK\jre\lib\javaws.jar;
F:\java\JDK\jre\lib\jce.jar;
F:\java\JDK\jre\lib\jfr.jar;
F:\java\JDK\jre\lib\jfxswt.jar;
F:\java\JDK\jre\lib\jsse.jar;
F:\java\JDK\jre\lib\management-agent.jar;
F:\java\JDK\jre\lib\plugin.jar;
F:\java\JDK\jre\lib\resources.jar;
F:\java\JDK\jre\lib\rt.jar;
F:\java\IDEA2020.2\Study\out\production\Study;
F:\java\JDK\jre\lib\commons-io-2.6.jar;
F:\java\IDEA2020.2\IntelliJ IDEA 2020.2.2\lib\idea_rt.jar
*/
}
}
4. 獲取運(yùn)行類的完整結(jié)構(gòu)
- 通過(guò)反射獲取運(yùn)行時(shí)類的完整結(jié)構(gòu)
- Field摘昌、 Method速妖、 Constructor.、 Superclass聪黎、 Interface、 Annotation
- 實(shí)現(xiàn)的全部接口
- 所繼承的父類
- 全部的構(gòu)造器
- 全部的方法
- 全部的Feld
- 注解
- ……
- 實(shí)例：獲得類的信息
package com.xxx.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 獲得類的信息
*/
public class Test07 {
public static void main(String[] args) throws Exception {
Class c1 = Class.forName("com.xxx.reflection.User");
User user = new User();
c1 = user.getClass();
// 獲取類的名字
System.out.println(c1.getName()); // 獲得包名 + 類名
System.out.println(c1.getSimpleName()); // 獲得類名
// 獲得類的屬性
System.out.println("------------------------");
Field[] fields = c1.getFields(); // 只能找到public屬性
fields = c1.getDeclaredFields(); // 找到全部的屬性
for (Field field : fields) {
System.out.println(field);
}
// 獲得指定屬性的值
System.out.println("------------------------");
Field name = c1.getDeclaredField("name");
System.out.println(name);
// 獲得類的方法
Method[] methods = c1.getMethods(); // 獲得本類及父類的全部public方法
for (Method method : methods) {
System.out.println("getMethods:" + method);
}
methods = c1.getDeclaredMethods(); // 獲得本類的所有方法
for (Method method : methods) {
System.out.println("getDeclaredMethods:" + method);
}
System.out.println("------------------------");
// 獲得指定的方法
// 重載
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
// 獲得類的構(gòu)造器
System.out.println("------------------------");
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println("getConstructors:" + constructor);
}
constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println("getDeclaredConstructors:" + constructor);
}
// 獲得指定的構(gòu)造器
System.out.println("------------------------");
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
System.out.println("指定構(gòu)造器" + declaredConstructor);
}
}
- 在實(shí)際的操作中备恤，取得類的信息的操作代碼稿饰，并不會(huì)經(jīng)常開(kāi)發(fā)。
- 一定要熟悉
java.lang.reflect包的作用露泊，反射機(jī)制喉镰。 - 如何取得屬性、方法惭笑、構(gòu)造器的名稱侣姆，修飾符等。
5. 調(diào)用運(yùn)行時(shí)類的指定結(jié)構(gòu)
- 有 Class 對(duì)象,能做什么
- 創(chuàng)建類的對(duì)象：調(diào)用 Class 對(duì)象的 newInstance() 方法
- 類必須有一個(gè)無(wú)參數(shù)的構(gòu)造器沉噩。
- 類的構(gòu)造器的訪問(wèn)權(quán)限需要足夠捺宗。
- 思考？沒(méi)有無(wú)參的構(gòu)造器川蒙，就不能創(chuàng)建對(duì)象了嗎蚜厉？只要在操作的時(shí)候，明確的調(diào)用類中的構(gòu)造器畜眨，并將參數(shù)傳遞進(jìn)去之后昼牛，才可以實(shí)例化操作。
- 步驟如下：
- 通過(guò) class 類的 getDeclaredConstructor（ Class…康聂， parameterTypes）取得本類的指定形參類型的構(gòu)造器贰健；
- 向構(gòu)造器的形參中傳遞一個(gè)對(duì)象數(shù)組進(jìn)去，里面包含了構(gòu)造器中所需的各個(gè)參數(shù)恬汁。
- 通過(guò) Constructor 實(shí)例化對(duì)象
- 方法及使用
package com.xxx.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 通過(guò)反射：動(dòng)態(tài)的創(chuàng)建對(duì)象
*/
public class Test08 {
public static void main(String[] args) throws Exception {
// 獲得 Class 對(duì)象
Class c1 = Class.forName("com.xxx.reflection.User");
// 構(gòu)造一個(gè)對(duì)象
User user = (User) c1.newInstance();
System.out.println(user); // 本質(zhì)上調(diào)用了類的無(wú)參構(gòu)造器
// 通過(guò)構(gòu)造器創(chuàng)建對(duì)象
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
User user1 = (User) constructor.newInstance("User1", 001, 20);
System.out.println(user1);
// 通過(guò)反射調(diào)用普通方法
User user2 = (User) c1.newInstance();
// 通過(guò)反射獲取一個(gè)方法
Method setName = c1.getDeclaredMethod("setName", String.class);
// invoke:激活
// (對(duì)象,"方法值")
setName.invoke(user2, "some");
System.out.println(user2.getName());
// 通過(guò)反射操作屬性
User user3 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
// 不能直接操作私有屬性,我們需要關(guān)閉程序的安全檢測(cè),屬性或方法的setAccessible(true)
// 設(shè)置安全檢測(cè)
name.setAccessible(true);
name.set(user3, "some2");
System.out.println(user3.getName());
}
}
- 通過(guò)反射伶椿，調(diào)用類中的方法，通過(guò) Method 類完成蕊连。
- 通過(guò) Class 類的 getMethod（ String name, Class… parameterTypes）方法取得一個(gè) Method 對(duì)象悬垃，并設(shè)置此方法操作時(shí)所需要的參數(shù)類型。
- 之后使用 Object invoke（ Object obj甘苍，Object[] args）進(jìn)行調(diào)用尝蠕，并向方法中傳遞要設(shè)置的 obj 對(duì)象的參數(shù)信息。
調(diào)用指定的方法：
- Object invoke（object obj, Object. args）
- Object 對(duì)應(yīng)原方法的返回值载庭，若原方法無(wú)返回值看彼，此時(shí)返回 null廊佩；
- 若原方法為靜態(tài)方法，此時(shí)形參 Object obj 可為 null靖榕；
- 若原方法形參列表為空标锄，則 Object[] args為 null；
- 若原方法聲明為 private茁计，則需要在調(diào)用此 invoke() 方法前料皇，顯式調(diào)用方法對(duì)象的 setAccessible(true) 方法，將可訪問(wèn) private 的方法星压。
setAccessible() ：安全檢查
- Method 和 Field践剂、 Constructor 對(duì)象都有 setAccessible() 方法。
- setAccessible 作用是：?jiǎn)?dòng)和禁用訪問(wèn)安全檢查的開(kāi)關(guān)娜膘。
- 參數(shù)值為 true逊脯，則指示反射的對(duì)象在使用時(shí)，應(yīng)該取消 Java 語(yǔ)言訪問(wèn)檢査竣贪。
- 提高反射的效率军洼。如果代碼中必須用反射，而該句代碼需要頻繁的被調(diào)用演怎，那么請(qǐng)?jiān)O(shè)置為 true匕争；
- 使得原本無(wú)法訪問(wèn)的私有成員也可以訪問(wèn)；
- 參數(shù)值為 false颤枪，則指示反射的對(duì)象汗捡，應(yīng)該實(shí)施 Java 語(yǔ)言訪問(wèn)檢查。
- 性能檢測(cè)
package com.xxx.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 分析性能問(wèn)題
*/
public class Test09 {
public static void main(String[] args) throws Exception {
test01();
test02();
test03();
}
// 普通方式調(diào)用
public static void test01() {
User user = new User();
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
user.getName();
}
long endTime = System.currentTimeMillis();
System.out.println("普通方式執(zhí)行10億次：" + (endTime - startTime) + "ms");
}
// 反射方式調(diào)用
public static void test02() throws Exception {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getDeclaredMethod("getName", null);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user, null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射方式執(zhí)行10億次：" + (endTime - startTime) + "ms");
}
// 反射方式調(diào)用,關(guān)閉檢測(cè)
public static void test03() throws Exception {
User user = new User();
Class c1 = user.getClass();
Method getName = c1.getDeclaredMethod("getName", null);
getName.setAccessible(true);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user, null);
}
long endTime = System.currentTimeMillis();
System.out.println("關(guān)閉檢測(cè)執(zhí)行10億次：" + (endTime - startTime) + "ms");
}
}
6. 反射操作泛型
- Java 采用泛型擦除的機(jī)制來(lái)引入泛型畏纲，Java 中的泛型扇住，僅僅是給編譯器 javac 使用的，確保數(shù)據(jù)的安全性盗胀，和免去強(qiáng)制類型轉(zhuǎn)換問(wèn)題艘蹋，但是，一旦編譯完成票灰，所有和泛型有關(guān)的類型全部擦除女阀。
- 為了通過(guò)反射操作這些類型，Java 新增了 ParameterizedType, GenericArrayType, TypeVariable 和 WildcardType 幾種類型屑迂，來(lái)代表不能被歸一到 Class 類中的類型浸策，但是又和原始類型齊名的類型。
- ParameterizedType：表示一種參數(shù)化類型惹盼，比如 Collection< String>
- GenericArrayType：表示一種元素類型是參數(shù)化類型庸汗，或者類型變量的數(shù)組類型；
- TypeVariable：是各種類型變量的公共父接口手报；
- WildcardType：代表一種通配符類型表達(dá)式蚯舱。
package com.xxx.reflection;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
/**
* 通過(guò)反射獲取泛型
*/
public class Test10 {
public void test01(Map<String, User> map, List<User> list) {
System.out.println("test01");
}
public Map<String, User> test02() {
System.out.println("Test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test10.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println("#" + genericParameterType);
if (genericParameterType instanceof ParameterizedType) {
Type[] typeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type typeArgument : typeArguments) {
System.out.println(typeArgument);
}
}
}
method = Test10.class.getMethod("test02", null);
Type returnType = method.getGenericReturnType();
if (returnType instanceof ParameterizedType) {
Type[] typeArguments = ((ParameterizedType) returnType).getActualTypeArguments();
for (Type typeArgument : typeArguments) {
System.out.println(typeArgument);
}
}
}
}
7. 反射操作注解
- getAnnotations
- getAnnotation
package com.xxx.reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
/**
* 反射操作注解
*/
public class Test11 {
public static void main(String[] args) throws Exception {
Class c1 = Class.forName("com.xxx.reflection.Student2");
// 通過(guò)反射獲得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 獲得注解 value 的值
Table table = (Table) c1.getAnnotation(Table.class);
String value = table.value();
System.out.println(value);
// 獲得類指定的注解
Field f = c1.getDeclaredField("name");
Filed annotation = f.getAnnotation(Filed.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Table("db_student")
class Student2 {
@Filed(columnName = "db_id", type = "int", length = 10)
private int id;
@Filed(columnName = "db_age", type = "int", length = 10)
private int age;
@Filed(columnName = "db_name", type = "varchar", length = 3)
private String name;
public Student2() {
}
public Student2(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
@Override
public String toString() {
return "Student2{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
// 類名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
String value();
}
// 屬性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Filed {
String columnName();
String type();
int length();
}
