java注解與反射

java注解與反射十分重要，是很多框架的底層

注解（Annotataion）

注解的作用：

   1. 不是程式本身，可以對程式作出解釋
   1. 可以被其他程式讀取

注解的格式：@注釋名，如@override表示重寫方法，而且有些還可以添加一些引數值，如@SuppressWarnings(value="https://www.cnblogs.com/rainaftersummert/archive/2023/05/30/unchecjed")
注解可以附加在package，class，method，field等上面，相當于添加了額外的輔助資訊，可以通過反射機制編程實作對這些元資料的訪問

內置注解

@Override:重寫方法
@Deprecated:表示不被鼓勵使用或者已廢棄已過時
@SuppressWarning:用來抑制編譯時的警告資訊,但是需要添加一個或多個引數:如（"all"），（"unchecked"）等，平時最好還是不要用這個

使用方法：

@Override
public  void run() {
}

其他類似，

元注解

負責注解其他注解
包括（@Target,@Retention,@Documented,@Inherited），分別表示
1. 描述注解使用范圍
2. 需要上面級別保存該注釋資訊，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME，分別表示源代碼，編譯后的class檔案，運行時）
3. 說明該注解將被包含在javadoc中
4. 說明子類可以繼承父類中的該注解

//下面只能用到方法上,value的值可以取多個至于那些可以取CTRL+左鍵點擊ElementType類去看，另外可以省略value=
https://www.cnblogs.com/rainaftersummert/archive/2023/05/30/@Target(value = ElementType.METHOD)
//只能存在于原始碼上，值有那些同上，自己點進去看RetentionPolicy類,一般取RUNTIME
@Retention(value = RetentionPolicy.SOURCE)
//這兩個不多說
@Documented
@Inherited
//自定義注解
@interface MyAnnotation{

}

自定義注解

使用@interface自定義注解，格式 public @interface 注解名{}
其中每一個方法實際上是宣告了一個配置引數
方法名稱就是引數名稱
回傳值型別就是引數型別（回傳值只能是基本型別或class，String，enum）
可以用default來宣告引數的默認值
如果只有一個引數，一般引數名為value，只有一個引數時使用可以不寫引數名=
注解元素必須有值，我們定義注解元素時，經常使用空字串，默認值為0

//元注解
@Retention(RetentionPolicy.RUNTIME)
@Inherited
//自定義注解
@interface MyAnnotation{
//    注解引數：引數型別+引數名()，可以設定默認值，沒默認值的話使用時必須傳參
    String name() default "";
    int a();
    int c() default 1;
}

//使用
@MyAnnotation(name = "lihua",a = 1)

反射（Reflection）

java是一個靜態語言（還有c，c++），因為它相對于動態語言來說，運行時結構不變，但是java可以利用反射來獲得類似動態語言的特性，成為“準動態語言”，

動態語言就是運行時可以改變其結構的語言，如：c#，js，php，python等

反射機制運行程式在執行的程序中通過反射取得任何類的內部資訊，并且能夠直接操作任意物件的內部屬性及方法，
主要API是Class
反射是什么？

參考一下Class物件在java編譯運行的那個部分：

反射提供的部分功能：

優點與缺點

優點：動態編譯和創建，體現很大的靈活性

缺點：對性能有影響

Class類

除了之前描述的，Class類還有一些特征：

Class 本身也是一個類
Class物件只能有系統建立物件
一個加載的類在JVM中只會有一個Class實體
一個Class物件對應的是一個加載到JVM中的一個.class檔案
每個類的實體都會記得自己是由那個Class實體所生成的
通過Class可以完整得到一個類中的所有被加載結構
Class類是反射的根源，，你要進行的任何針對類的動態加載運行等反射操作，都需要先得到該類的Class物件

public static void main(String[] args) throws ClassNotFoundException {
    /*1.下面是通過反射獲取Class物件的一種方式,引數是檔案路徑
      2.一個類在記憶體中只有一個Class類，在多創建幾個該類的Class
     也是同一個，
      3一個類被加載后，類的整個結構都會被封裝在Class物件中
      4.我們經常用的Object的getClass方法就是回傳一個Class物件，也是創建Class物件的一種常用方式
      5.反射在某種情況下可以理解為通過一個物件獲得類
     */
    Class<?> aClass = Class.forName("com.xxx.MyThread");
    System.out.println(aClass);
}

//out:class com.xxx.MyThread

Class類的常用方法：

Class類的四種創建方式

雖然上面可能已經描述過Class物件的創建方式的兩種，這里還是再來具體寫一下：

public class Test {

    public static void main(String[] args) throws ClassNotFoundException {
        Teacher teacher = new Teacher();
//        方式一:通過物件
        Class aClass = teacher.getClass();
        System.out.println(aClass);
//        方式二：forname
        Class<?> class1 = Class.forName("com.xxx.Teacher");
        System.out.println(class1);
//        比較兩者
        System.out.println(aClass==class1);
//        方式三：通過類名.class獲得
        Class<Teacher> teacherClass = Teacher.class;
        System.out.println(teacherClass);
//        比較
        System.out.println(teacherClass==class1);
//        方式四：基本資料型別的包裝類的type屬性
        Class<Integer> type = Integer.TYPE;
        System.out.println(type);
//        得到父類Class型別
        Class<?> superclass = class1.getSuperclass();
        System.out.println(superclass);
//     補充一下，獲得注解和void和Class本身的Class物件
        // Override.class
        // void.class
        //Class.class

    }
}

class Teacher extends  Person{}

/*
class com.xxx.Teacher
class com.xxx.Teacher
true
class com.xxx.Teacher
true
int
class com.xxx.Person

那些型別可以有Class物件？

包括以下：

注意：陣列長度即使不一致，只要型別和維度一樣，就是同一個Class

Class類的方法

獲得類完整結構

public class MyThread {
    private  int a;
    public  void run(String a){}

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public MyThread(int a) {
        this.a = a;
    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class c1 = Class.forName("com.xxx.MyThread");
        //獲取類名
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());
//        獲得類屬性
        Field[] fields = c1.getFields();//只能找到public屬性
        fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
//        獲得類方法
        System.out.println("-----------------------");
        Method[] methods = c1.getMethods();//包括繼承的方法
        methods=c1.getDeclaredMethods();//只包括本類的方法
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-------------------------------");
//        獲得指定方法:沒s，兩個引數分別是方法名和方法引數型別的Class
        System.out.println(c1.getMethod("run",String.class));
//        獲得構造器
        System.out.println("----------------");
        Constructor[] constructors = c1.getConstructors();//獲得public構造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
//        同理getDeclaredConstructors()獲得的所有構造器，

        //獲得指定的構造器,引數為構造器引數的Class
        System.out.println("--------------------------");
        Constructor constructor = c1.getConstructor(int.class);
        System.out.println(constructor);
    }
}
/*out:

public void com.xxx.MyThread.run(java.lang.String)
public void com.xxx.MyThread.setA(int)
public int com.xxx.MyThread.getA()
-------------------------------
public void com.xxx.MyThread.run(java.lang.String)
----------------
public com.xxx.MyThread(int)
--------------------------
public com.xxx.MyThread(int)

操作類結構

public class MyThread {
    private  int a;
    public  void run(String a){
        System.out.println(a);
    }

    public int getA() {
        return a;
    }

    public MyThread() {
    }

    public void setA(int a) {
        this.a = a;
    }

    public MyThread(int a) {
        this.a = a;
    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.xxx.MyThread");
//        構建一個物件:本質是呼叫無參構造器，其該類必須有無參構造器
//        MyThread myThread = (MyThread)aClass.newInstance();
//        通過構造器創建物件,可以用有參建構式
//       Constructor constructor= aClass.getDeclaredConstructor(int.class);
//       MyThread myThread1=(MyThread)constructor.newInstance(1);

//       通過反射呼叫方法
//        通過反射獲取一個方法
        MyThread myThread = (MyThread) aClass.newInstance();
        Method setName = aClass.getMethod("run", String.class);
//        invoke:激活，引數：物件名，方法引數
        setName.invoke(myThread,"helloworld");

//        通過反射操作屬性
        Field a=aClass.getDeclaredField("a");
//        取消安全檢查，否則無法操作私有屬性.method,field,consructor都有它，關閉也可以提高反射效率
        a.setAccessible(true);
        a.set(myThread,5);
        System.out.println(myThread.a);
    }
    
   /*out:
   helloworld
	5

類的加載程序

解釋一下符號參考和直接參考：

符號參考你可以理解為要參考的類目前在記憶體中還沒被加載出來，JVM當然不知道它在哪里，所以就用唯一的符號來表示就好像給它賦了一個變數，等到鏈接的時候類加載器決議地址完成變成直接參考

直接參考就是存盤參考類在真實記憶體中的地址

總而言之還是這張圖：

什么時候會發生類的初始化

主動參考比較好理解，下面只演示一下被動參考“

public class Main {
       //    初始化時執行一次靜態代碼塊
    static {
        System.out.println("main函式所在類被加載了");
    }
    public static void main(String[] args) throws ClassNotFoundException {
       System.out.println(son.sonAge);
       /*
       out:
       main函式所在類被加載了
       父類被加載了
       子類被加載了
       10
        */
//------------------------------------------------------
//        這就是第一條的意思
        System.out.println(son.fatherAge);
        /*
            out:
             main函式所在類被加載了
             父類被加載了
             23
         */
//--------------------------------------------------------
//      第二條：本質上只是開辟了一片空間
        son[] arr = new son[5];
        /*
        out:
        main函式所在類被加載了
         */
//--------------------------------------------------------
        //常量是不會引起初始化的
        System.out.println(son.M);
        /*
        out:
        main函式所在類被加載了
        1
         */
    }
}

class  father {
    static int fatherAge = 23;

    //    初始化時執行一次靜態代碼塊
    static {
        System.out.println("父類被加載了");
    }
}
class son extends father{
    static  int sonAge = 10;
    static  final  int M = 1;
    static {
        System.out.println("子類被加載了");
    }
}

類加載器

類加載的作用：將class檔案位元組碼內容加載到記憶體中，并且將這些靜態資料轉換成方法區的運行時資料結構，然后在堆中生成一個代表這個類的java.lang.Class 物件，作為方法區中類資料的訪問入口，簡單來說，類加載器的作用就是把類（class）裝進記憶體
類快取：標準的JavaSE類加載器可以按照要求查找類，但一旦某個類被加載到類加載器中，它將維持加載（快取）一段資料，不過JVM垃圾回識訓制可以回收這些Class物件

類加載器有那些？

java的主要jar包就是rt.jar，引導類加載器就是加載這一類核心jar包

 public static void main(String[] args) throws ClassNotFoundException {
//        獲取系統類的加載器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);

//        獲取系統類加載器的父類加載器-->拓展加載器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);
//        獲得拓展類加載器的父類加載器-->根加載器(c/c++):這個java是無法獲得的
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);

        System.out.println("------------------------");

//        測驗當前類是那個加載器加載的
        ClassLoader classLoader3 = Class.forName("com.xxx.MyThread").getClassLoader();
        System.out.println(classLoader3);
//        測驗jdk內部類是誰加載的：根加載器，輸出不出來
        ClassLoader classLoader4 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader4);

        //如何獲得系統類加載器可以加載的路徑
        System.out.println(System.getProperty("java.class.path"));

    }

/*out:
jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
jdk.internal.loader.ClassLoaders$PlatformClassLoader@5594a1b5
null
------------------------
jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
null
本處按道理來說應該輸出所有jar包路徑，但是只說出了檔案根目錄，可能是因為jdk版本的原因，不確定，本處存疑

反射操作泛型

public class MyThread {
   public void test01(Map<String,MyThread> map, List<MyThread> list){
   }
   public  Map<String,Map> test02(){
       return  null;
   }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
       //獲得引數泛型
       Method method = MyThread.class.getMethod("test01", Map.class,List.class);
       //得到的是方法的引數Map，List
        Type[] genericExceptionTypes = method.getGenericParameterTypes();
        for (Type genericExceptionType : genericExceptionTypes) {
            if(genericExceptionType instanceof ParameterizedType){
                System.out.println(genericExceptionType);
                //得到的是方法引數的泛型
                Type[] actualTypeArguments = ((ParameterizedType) genericExceptionType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        //獲得回傳值泛型
        Method method1 = MyThread.class.getMethod("test02");
        Type genericReturnType = method1.getGenericReturnType();
        if(genericReturnType instanceof  ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }

}

/*
java.util.Map<java.lang.String, com.xxx.MyThread>
class java.lang.String
class com.xxx.MyThread
java.util.List<com.xxx.MyThread>
class com.xxx.MyThread
class java.lang.String
interface java.util.Map

反射操作注解

ORM->物件關系映射

public class MyThread {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.xxx.Teacher");
//        通過反射獲得注解
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
//        獲得注解的value值
        Table table = (Table) aClass.getAnnotation(Table.class);
        String value = https://www.cnblogs.com/rainaftersummert/archive/2023/05/30/table.value();
        System.out.println(value);

//        獲得類指定注解
        Field f = aClass.getDeclaredField("id");
        Table annotation = f.getAnnotation(Table.class);
        System.out.println(annotation.value());


    }
}
@Table(value = "https://www.cnblogs.com/rainaftersummert/archive/2023/05/30/aaa")
class Teacher{
    @Table2(value = "https://www.cnblogs.com/rainaftersummert/archive/2023/05/30/aaa")
    private int id;
    @Override
    public String toString() {
        return super.toString();
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String value();
        }
//屬性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Table2{
    String value();
}

/*
@com.xxx.Table(value="https://www.cnblogs.com/rainaftersummert/archive/2023/05/30/aaa")
aaa

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/553828.html

標籤：其他

上一篇：Python連接es筆記三之es更新操作

下一篇：返回列表