Java註解和反射
1、註解（Annotation）
1.1、什麼是註解(Annotation)
註解不是程式本身，可以在程式編譯、類載入和運行時被讀取，並執行相應的處理。註解的格式為”@注釋名(參數值)”，可以附加在包、類、方法和欄位上，通過反射機制實現實現註解的訪問。
1.2、內置註解
@Override：限定子類重寫方法
該註解表示覆蓋的是其父類的方法，當子類重寫父類方法時，確保子類確實重寫了父類的方法，避免出現低級錯誤
/**
* 該註解標識覆蓋的是其父類的方法，當子類重寫父類方法時，確保子類確實重寫了父類的方法，避免出現低級錯誤
* @return
*/
@Override
public String toString() {
return super.toString();
}
@Deprecated：標記已過時
該註解表示某個屬性、方法或類等已過時（程式設計師不鼓勵使用的程式元素，通常是因為它是危險的，或者因為存在更好的替代方法），當其他程式使用已過時的屬性、方法或者類時，編譯器會給出警告（刪除線）。
/**
* 該註解表示此方法已過時，存在危險，不推薦使用，其有代替方法，如果繼續使用會通過刪除線進行標識
*/
@Deprecated
public static void test() {
System.out.println("標記已過時");
}
@SuppressWarnings(參數)：抑制編譯器警告
該註解作用的類、方法和屬性會取消顯示編譯器警告，其參數主要是進行警告說明以及取消(unchecked)等。
@SuppressWarnings("取消此類的所有警告")
public class BuiltAnnotation {
@SuppressWarnings("取消此屬性的警告")
private String username;
@SuppressWarnings("取消此方法的警告")
public static void main(String[] args) {
// ...
}
}
1.3、元註解(meta-annotation)
元註解的作用就是負責註解其他註解，Java定義了4個標準的元註解類型，他們被用來提供對其他註解的作用範圍及類型進行說明，通過元註解可以自定義其他註解。
@Target：描述註解的使用範圍
例如@Target(ElementType.METHOD)表示作用在方法上，@Target(ElementType.TYPE)表示作用在類或介面上等
/**
* @Target註解：描述註解的使用範圍
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
/**
* 類或介面：ElementType.TYPE；
* 欄位：ElementType.FIELD；
* 方法：ElementType.METHOD；
* 構造方法：ElementType.CONSTRUCTOR；
* 方法參數：ElementType.PARAMETER；
* ...
*/
ElementType[] value();
}
@Retention：表示需要在什麼級別保存該註解資訊，用於描述註解的生命周期
通常自定義的註解都使用@Retention(RetentionPolicy.RUNTIME)，也就是運行時期作用。
/**
* @Retention：表示需要在什麼級別保存該註解資訊，用於描述註解的生命周期
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
/**
* RetentionPolicy.SOURCE：僅編譯期，註解將被編譯器丟棄。
* RetentionPolicy.CLASS：僅class文件，注釋將由編譯器記錄在類文件中，但VM不需要在運行時保留，如果不指定則默認為class。
* RetentionPolicy.RUNTIME：運行期，注釋將由編譯器記錄在類文件中，並由VM在運行時保留，因此可以反射讀取。通常自定義的註解都是RUNTIME。
* 範圍：RUNTIME>CLASS>SOURCE
*/
RetentionPolicy value();
}
@Document：說明該注將被包含在javadoc中
@Iherited：定義子類是否可繼承父類定義的註解。
@Inherited僅針對 @Target(ElementType.TYPE) 類型的註解有用，並且只能是 class 的繼承，對 interface 的繼承無效：
1.4、自定義註解
定義註解
/**
* 1. 使用@interface定義註解；
* 3. 通過元註解配置該註解，配置註解的使用範圍和生命周期等
* @author Loner
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Report{
/**
* 2. 添加參數、默認值，如果沒有默認值，就必須給參數賦值，一般把最常用的參數定義為value()，推薦所有參數都盡量設置默認值
* 形式為：參數類型 參數名()；
*/
int type() default 0;
String value() default "LonerMJ";
}
使用註解
@Report(type = 1, value = "test")
public class CustomerAnnotation {
@Report(type = 1, value = "test")
public void testCustomerAnnotation() {
System.out.println("測試自定義註解");
}
}
2、反射（Reflection）
2.1、反射和反射機制
反射
Reflection（反射）是指程式在運行期可以拿到一個對象的所有資訊。
反射機制
反射機制是指程式在運行時，通過Reflection API獲取任何類的內容資訊，並能直接操作任何對象的內部屬性及方法。
2.2、Class類的獲取方式和常用方法
java.lang.Class類，實現反射的核心類，類載入完成之後，在堆記憶體的方法區中就會產生一個Class對象（一個類只有一個Class對象），這個對象包含了類的完整結構資訊，通過這個對象看到類的結構。
Class類的獲取方式
public class InstantiationClass {
public static void main(String[] args) throws ClassNotFoundException {
Teacher teacher = new Teacher("張三", "123456");
// 方式一：調用Class類的靜態方法forName(String className)
Class<?> c1 = Class.forName("com.loner.mj.reflection.Teacher");
// 方式二：已知某個類的實例，調用該實例的getClass()方法，getClass是Object類中的方法。
Class<? extends Teacher> c2 = teacher.getClass();
// 方式三：已知具體類，通過類的class屬性獲取，該方法最安全可靠，程式性能最高
Class<Teacher> c3 = Teacher.class;
// 方式四：通過基本內置類型的包裝類的TYPE屬性獲得CLass實例
Class<Integer> c4 = Integer.TYPE;
// 方式五：通過當前子類的Class對象獲得父類的Class對象
Class<?> c5 = c1.getSuperclass();
}
}
Class類的常用方法
| 方法名 | 方法功能 |
|---|---|
| static Class forName(String name) | 返回指定類名的Class對象 |
| Obiect newInstance() | 調用無參構造函數，返回Class對象的一個實例 |
| String getName() | 返回此Class對象所表示的實體（類，介面，數組類或void）的名稱 |
| Class getSuperclass() | 返回當前Class對象的父類的Class對象 |
| Class[] getinterfaces() | 返回當前Class對象的介面 |
| ClassLoader getClassLoader() | 返回該類的類載入器 |
| Method getDeclareMethod(String name, Class<?> … parameterTypes) | 獲取方法名和參數列表匹配的方法 |
| Method[] getDeclareMethods() | 獲取所有非繼承的方法 |
| Method[] getMethods() | 獲取所有非私有方法 |
| Field getDeclareField(String name) | 獲取指定屬性 |
| Field[] getDeclareFields() | 獲取所有屬性 |
| Field[] getFields() | 獲取所有非私有屬性 |
| Constructor |
獲取參數列表匹配的構造方法 |
| Constructor |
獲取類的所有構造方法 |
| A getAnnotation(Class<?> annotationClass) | 返回指定註解 |
| Annotation[] getDeclaredAnnotations() | 返回所有註解 |
public class ReflectionMethods {
public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
Class<Worker> workerClass = Worker.class;
/**
* 類
*/
System.out.println(workerClass.getName());
System.out.println(workerClass.getSimpleName());
System.out.println(workerClass.getSuperclass());
System.out.println(workerClass.getPackage());
Class<?>[] interfaces = workerClass.getInterfaces();
for (Class<?> i : interfaces) {
System.out.println(i);
}
/**
* 屬性
*/
// 獲取所有的屬性
Field[] declaredFields = workerClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
// 獲取指定屬性
System.out.println(workerClass.getDeclaredField("username"));
// 獲取所有公共屬性
Field[] fields = workerClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
/**
* 構造方法
*/
// 獲取所有構造方法
Constructor<?>[] declaredConstructors = workerClass.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
// 獲取指定的構造方法
System.out.println(workerClass.getDeclaredConstructor(String.class, String.class));
/**
* 方法
*/
// 獲取所有的方法
Method[] declaredMethods = workerClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
// 獲取指定方法
System.out.println(workerClass.getDeclaredMethod("getUsername", null));
// 獲取所有功能方法
Method[] methods = workerClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
}
}
哪些類型具有Class對象
public class InstantiationClass {
public static void main(String[] args) throws ClassNotFoundException {
// 類（外部類，成員（成員內部類，靜態內部類），局部內部類，匿名內部類。）
Class<Object> objectClass = Object.class;
// 介面
Class<Comparable> comparableClass = Comparable.class;
// 數組
Class<String[]> stringClass = String[].class;
Class<int[][]> intClass = int[][].class;
// 枚舉
Class<ElementType> elementTypeClass = ElementType.class;
// 註解
Class<Override> overrideClass = Override.class;
// 基本數據類型
Class<Integer> integerClass = Integer.class;
// void
Class<Void> voidClass = void.class;
// Class
Class<Class> classClass = Class.class;
}
}
2.3、反射的使用
反射操作對象
public class UseClass {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
Class<User> userClass = User.class;
/**
* 通過構造器實例化對象：不使用構造器，默認通過無參構造進行對象創建
*/
Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(String.class, String.class);
User user = declaredConstructor.newInstance("張三", "123456");
System.out.println(user);
/**
* 調用方法並執行相關操作
*/
Method setUsername = userClass.getDeclaredMethod("setUsername", String.class);
// invoke(Object, 參數)：激活，即執行相關操作為該對象
setUsername.invoke(user, "李四");
Method setPassword = userClass.getDeclaredMethod("setPassword", String.class);
setPassword.invoke(user, "123456");
System.out.println(user);
/**
* 操作屬性：通過反射直接操作私有屬性會報錯，需要通過setAccessible(ture)關閉訪問安全檢查，此方法屬性、方法和構造都具有，會影響效率
*/
Field username = userClass.getDeclaredField("username");
username.setAccessible(true);
username.set(user, "用戶名");
System.out.println(user);
}
}
反射操作泛型
Java採用泛型擦除的機制來引入泛型，Java中的泛型僅僅是給編譯器javac使用的，確保數據的安全性和免去強制類型轉換問題。但是，一旦編譯完成，所有和泛型有關的類型全部擦除。
為了通過反射操作這些類型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType幾種類型來代表不能被歸一到Class類中的類型但是又和原始類型齊名的類型。
ParameterizedType：表示一種參數化類型，比如Collection
GenericArrayType：表示一種元素類型是參數化類型或者類型變數的數組類型
TypeVariable：是各種類型變數的公共父介面
WildcardType：代表一種通配符類型表達式
public class ClassOperateGenerics {
public Map<String, String> list() {
System.out.println("返回值是泛型");
return new HashMap<>();
}
public void test(Map<String, User> map, List<Integer> list) {
System.out.println("參數是泛型");
}
public static void main(String[] args) throws NoSuchMethodException {
/**
* 獲取方法參數的泛型
*/
Method method = ClassOperateGenerics.class.getMethod("test", Map.class, List.class);
// 獲取所有方法參數的泛型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
// java.util.Map<java.lang.String, com.loner.mj.reflection.User>
System.out.println(genericParameterType);
if (genericParameterType instanceof ParameterizedType) {
// 獲取所有泛型的真實參數
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
// String, User, Integer
System.out.println(actualTypeArgument);
}
}
}
/**
* 獲取方法返回值的泛型
*/
Method list = ClassOperateGenerics.class.getMethod("list", null);
// 獲取方法返回值的泛型
Type genericReturnType = list.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
// 獲取所有泛型的真實參數
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
反射操作註解
public class ClassOperateAnnotation {
public static void main(String[] args) throws NoSuchFieldException {
Class<People> peopleClass = People.class;
// 獲取類的所有註解
Annotation[] declaredAnnotations = peopleClass.getDeclaredAnnotations();
for (Annotation declaredAnnotation : declaredAnnotations) {
System.out.println(declaredAnnotation);
}
// 獲取類的註解的值
Table declaredAnnotation = peopleClass.getDeclaredAnnotation(Table.class);
System.out.println(declaredAnnotation.value());
// 獲取屬性的註解
Field name = peopleClass.getDeclaredField("name");
Fields annotation = name.getAnnotation(Fields.class);
System.out.println(annotation.name());
}
}
