國慶假期來臨，一起來玩io遊戲吧
阿新 • • 發佈：2020-10-02
一 註解機制
1.1 內建註解
@Override：此註解只適用於修飾方法，表示一個方法宣告打算重寫父類中的另一個方法宣告
@Deprecated：此註解可以修飾方法、屬性、類，表示不鼓勵程式設計師使用這樣的元素，通常因為它很危險或存在更好的選擇
@SuppressWarning：用來鎮壓編譯時的警告資訊
- @SuppressWarning("all")
- @SuppressWarning("unchencked")
- @SuppressWarning(values={"unchecked", "deprecation"})
@SuppressWarnings("all") public void test02(){ // 定義了但沒有使用，預設是會出現警告的，但加了註解之後，警告消失（被鎮壓） LinkedList list = new LinkedList(); }
1.2 元註解
元註解的作用就是負責註解其它的註解，Java定義了4個標準的meta-annotation型別，它們被用來提供對其它的annotation型別作說明。
- @Target：用於描述註解的使用範圍（即：被描述的註解可以用在什麼地方）
- @Retention：表示需要在什麼級別儲存該註解，用於描述註解的生命週期
- SOURCE < CLASS < RUNTIME（一般使用這個）
- @Document：說明該註解將被包含在javadoc中
- @Inherited：說明子類可以繼承父類中的註解
package zr.annotation; import java.lang.annotation.*; /** * 測試元註解 */ public class Test01 extends Object{ @MyAnnotation public void test(){ } } // 定義一個註解 @Inherited // Documented 表示是否將我們的註解生成在Javadoc中 @Documented // Recumented 表示註解的生命週期 @Retention(value = RetentionPolicy.RUNTIME) // Target 表示註解的使用範圍 @Target(value = {ElementType.METHOD, ElementType.TYPE}) @interface MyAnnotation{ }
1.3 自定義註解
使用@interface自動以註解時，自動繼承了java.lang.annotation.Annotation介面
- @interface用來宣告一個註解，格式：public @interface 註解名{定義內容}
- 其中的每一個方法實際上是聲明瞭一個配置引數
- 方法的名稱就是引數的名稱
- 返回值型別就是引數的型別（返回值只能是基本型別、Class、String、enum）
- 可以通過default來宣告引數的預設值
- 如果只有一個引數成員，一般引數名為value，在使用的時候可以把value省略掉
- 註解元素必須要有值，我們定義註解元素時，經常使用空字串、0作為預設值
二 反射機制
2.1 反射概念
Refelection（反射）是Java被視為動態語言的關鍵，反射機制允許程式在執行期藉助於Reflection API獲取任何類的內部資訊，並能直接操作任意物件的內部屬性及方法。
Class clazz = Class.forName("java.lang.String");
類載入完之後，在堆記憶體中就產生了一個Class型別的物件（一個類只有一個Class物件），這個物件就包含了完整的類的結構資訊，我們可以通過這個物件看到類的結構。這個物件就像一面鏡子，透過這個鏡子看到類的結構，所以我們形象地稱之為：反射。
建立物件的方式：
- 正常方式：引入需要的“包類”名稱—>通過new關鍵字例項化—>取得例項化物件
- 反射方式：例項化物件—>getClass()方法—>得到完整的“包類”名稱
2.2 反射相關的API
- java.lang.Class：代表一個類
- java.lang.reflect.Method：代表類的方法
- java.lang.reflect.Field：代表類的成員變數
- java.lang.reflect.Constructor：代表類的構造器
- ......
2.3 獲取Class類的例項
-
若已知具體的類，通過類的class屬性獲取，該方法最為可靠，程式效能最高
Class clazz = Person.class; -
已知某個類的例項，呼叫該例項的getClass()方法獲取Class物件
Class clazz = person.getClass(); -
已知一個類的全類名，且該類在類路徑下，可通過Class類的靜態方法forName()獲取
Class clazz = Class.forName("zr.reflection.User"); -
內建基本資料型別可以直接用類名.Type（比如Integer.Type返回的就是int）
-
利用ClassLoader
package zr.reflection;
public class Test01 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("這個人是: " + person.name);
// 方式一：通過物件獲得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
// 方式二：forName獲得
Class c2 = Class.forName("zr.reflection.Student");
System.out.println(c2.hashCode());
// 方式三：通過類名.class獲得
Class c3 = Student.class;
System.out.println(c3.hashCode());
// 獲取父類型別
Class c4 = c1.getSuperclass();
System.out.println(c4);
}
}
class Person{
public String name;
public Person(){}
public Person(String name) {
this.name = name;
}
}
class Student extends Person{
public Student(){
this.name = "學生";
}
}
package zr.reflection;
import java.lang.annotation.ElementType;
// 所有的型別的Class物件
public class Test02 {
public static void main(String[] args) {
// 類
Class c1 = Object.class;
// 介面
Class c2 = Comparable.class;
// 一維陣列
Class c3 = String[].class;
// 二維陣列
Class c4 = int[][].class;
// 註解
Class c5 = Override.class;
// 列舉
Class c6 = ElementType.class;
// 基本資料型別
Class c7 = Integer.class;
// void
Class c8 = void.class;
// Class本身
Class c9 = 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);
// 只要元素型別與維度一致，就是同一個Class物件
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}
// 輸出結果：
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class
356573597
356573597
2.4 什麼時候會發生類初始化
類的載入過程：載入—>連結—>初始化
2.4.1 類的主動引用
- 當虛擬機器啟動，先初始化main方法中的所有宣告的類
- new一個類的物件
- 呼叫類的靜態成員（除了final static靜態常量）和靜態方法
- 使用java.lang.reflection包的方法對類進行反射呼叫
- 當初始化一個類，如果其父類沒有被初始化，則先會初始化它的父類
2.4.2 類的被動呼叫（不會發生類的初始化）
- 當訪問一個靜態域，只有真正宣告這個域的類才會被初始化。如：子類引用父類的靜態變數，不會導致子類的初始化
- 通過陣列定義類引用
- 引用常量（因為常量在連結階段就已經存入呼叫類的常量池中了）
2.5 類載入器
類載入器的作用：將class位元組碼檔案內容載入到記憶體中，並將這些靜態資料轉換成方法區的執行時資料結構，然後在堆中生成一個代表這個類的一個java.lang.Class物件，作為方法去中類資料的訪問入口。
雙親委派模型：從下到上檢測類是否被載入，從上到下嘗試載入類
package zr.reflection;
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException {
// 獲取系統類的載入器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
// 獲取系統類載入器的父類載入器——>擴充套件類載入器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
// 獲取擴充套件類載入器的父類——>根載入器(C/C++寫的，所以一般獲得null)
ClassLoader boot = parent.getParent();
System.out.println(boot);
// 測試自定義類是由誰載入的（由系統類載入器載入）
ClassLoader loader = Class.forName("zr.reflection.Test01").getClassLoader();
System.out.println(loader);
// 測試JDK內部類是由誰載入的（由boot根載入器載入）
loader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(loader);
// 檢視系統類載入器可以載入的路徑
System.out.println(System.getProperty("java.class.path"));
/*
D:\Program Files\Java\jdk1.8.0_171\jre\lib\charsets.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\deploy.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\access-bridge-64.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\cldrdata.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\dnsns.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\jaccess.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\jfxrt.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\localedata.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\nashorn.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\sunec.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\sunjce_provider.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\sunmscapi.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\sunpkcs11.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\ext\zipfs.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\javaws.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\jce.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\jfr.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\jfxswt.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\jsse.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\management-agent.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\plugin.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\resources.jar;
D:\Program Files\Java\jdk1.8.0_171\jre\lib\rt.jar;
E:\idea\out\production\idea;
E:\idea\lib\mysql-connector-java-8.0.21.jar;
D:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2020.2.2\lib\idea_rt.jar
*/
}
}
// 輸出結果
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1540e19d
null
sun.misc.Launcher$AppClassLoader@18b4aac2
null
2.6 獲得類的執行時結構
package zr.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
// 獲得類的資訊
public class Test04 {
public static void main(String[] args) throws ClassNotFoundException {
Class clazz = Class.forName("zr.reflection.Student");
// 獲得類的名字
System.out.println(clazz.getName()); // 獲得包名 + 類名
System.out.println(clazz.getSimpleName()); // 獲得類名
// 獲得類的屬性
Field[] fields = clazz.getFields(); // 只能找到public屬性
fields = clazz.getDeclaredFields(); // 能獲得所有宣告的屬性
for(Field field : fields)
System.out.println(field);
// 獲得類的方法
Method[] methods = clazz.getDeclaredMethods(); // 獲取本類的所有方法（私有的也行）
for(Method method : methods)
System.out.println();
// 獲得類的構造器
Constructor[] constructors = clazz.getConstructors();
for(Constructor constructor : constructors)
System.out.println(constructor);
}
}
2.7 獲得Class物件後的操作
package zr.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
// 獲得類的資訊
public class Test04 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
// 獲得Class物件
Class clazz = Class.forName("zr.reflection.User");
// 構造一個物件
User user = (User)clazz.newInstance(); // 本質上是呼叫了類的無參構造器
System.out.println(user);
// 通過構造器建立物件，這樣就可以間接地去使用User的有參構造器
Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, int.class);
User xiaozeng = (User)constructor.newInstance("曾潤", 24, 99);
System.out.println(xiaozeng);
// 通過反射呼叫普通方法
Method setName = clazz.getDeclaredMethod("setName", String.class);
setName.invoke(xiaozeng, "範春春");
System.out.println(xiaozeng);
// 通過反射操作屬性
Field name = clazz.getDeclaredField("name");
// 首先需要設定許可權，防止private修飾的變數不能修改
name.setAccessible(true);
name.set(xiaozeng, "曾益達"); // 相當於賦值語句: name = "曾益達";
System.out.println(xiaozeng);
}
}
// 輸出
User{name='null', age=0, grade=0}
User{name='曾潤', age=24, grade=99}
User{name='範春春', age=24, grade=99}
User{name='曾益達', age=24, grade=99}
2.8 通過反射操作泛型
package zr.reflection;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
public class Test05 {
public static void test01(Map<String, User> map, List<User> list){
System.out.println("test01");
}
public static Map<String, User> test02(){
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Class clazz = Test05.class;
Method method = clazz.getDeclaredMethod("test01", Map.class, List.class);
// 獲得泛型的引數資訊
Type[] genericParameterTypes = method.getGenericParameterTypes();
for(Type genericParameterType : genericParameterTypes){
System.out.println("# " + genericParameterType);
Type[] actualyTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for(Type actualyTypeArgument : actualyTypeArguments)
System.out.println(actualyTypeArgument);
}
}
}
// 輸出結果
# java.util.Map<java.lang.String, zr.reflection.User>
class java.lang.String
class zr.reflection.User
# java.util.List<zr.reflection.User>
class zr.reflection.User
2.9 通過反射操作註解
package zr.reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;
public class Test06{
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class clazz = Class.forName("zr.reflection.Student1");
// 通過反射獲取類的註解
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 獲得註解的value值
Tablerun tablerun = (Tablerun) clazz.getAnnotation(Tablerun.class);
String value = tablerun.value();
System.out.println(value);
// 獲得類指定的註解
Field name = clazz.getDeclaredField("name");
Fieldrun annotation = name.getAnnotation(Fieldrun.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Tablerun("db_student")
class Student1{
@Fieldrun(columnName = "db_id", type = "int", length = 10)
private int id;
@Fieldrun(columnName = "db_age", type = "int", length = 10)
private int age;
@Fieldrun(columnName = "db_name", type = "varchar", length = 3)
private String name;
public Student1(){}
public Student1(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 "Student1{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
// 類名的註解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tablerun{
String value();
}
// 屬性的註解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldrun{
String columnName();
String type();
int length();
}
// 輸出結果
@zr.reflection.Tablerun(value=db_student)
db_student
db_name
varchar
3