15.注解和反射

1.注解-Annotation

作用：解釋；可被其他程序（如：編譯器等）讀取
格式：以“@注釋名”在代碼中存在，還可以添加一些參數值，如：@SUppressWarnings(value="unchecked")

2.內置注解

@Override：重寫
@Deprecated：表示不建議使用
@SuppressWarnings：用來抑制編譯時的警告信息

3.元注解

作用：復制注解其他注解
@Target：用于描述注解的使用范圍
@Retention：表示需要在什么級別保存該注釋信息，用于描述注解的生命周期
@Document：說明該注解被包含在 javadoc 中
@Inherited：說明資料可以繼承父類中的該注解

4.自定義注解

@interface 自定義注解，自動繼承了java.lang.annotation.Annotation接口
分析：

@interface用來聲明一個注解，格式：public @interface 注解名
其中的每個方法實際上是聲明了一個配置參數
方法的名稱就是參數的名稱
返回值類型就是參數的類型（返回值只能是基本類型，Class、String、enum）
可以通過default來聲明參數的默認值
如果只有一個參數成員，一般參數名為value
注解元素必須要有值，定義注解元素時，經常使用空字符串、0 作為默認值

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//自定義注解
public class Test02 {
    //注解可以顯示賦值，如果沒有默認值，就必須給注解賦值
    @MyAnnotation()
    public void test(){}
    //只有一個值
    @MyAnnotation2("value")
    public void test2(){}
}
//固定寫法
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的參數：參數類型 + 參數名();
    String name() default "";
    int age() default 0;
    int id() default -1;//如果默認值為-1，代表不存在
    String[] schools() default {"test1", "test2"};
}
@interface MyAnnotation2{
    String value();
}

5.反射機制-Reflection

5.1.Java Reflection

Reflection（反射）是Java被視為動態語言的關鍵，反射機制允許程序在執行期借助于 Reflection API 取得任何類的內部信息，并能直接操作任意對象的內部屬性及方法
Class c = Class.forName("java.lang.String")

反射

package reflection;
//反射
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通過反射獲取類的 Class 對象
        Class c1 = Class.forName("reflection.User");
        System.out.println(c1);

        Class c2 = Class.forName("reflection.User");
        Class c3 = Class.forName("reflection.User");
        Class c4 = Class.forName("reflection.User");
        //一個類在內存中只有一個 Class 對象
        //一個類被加載后，類的整個結構都會被封裝在 Class 對象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }

}
//實體類：pojo, entity
class User{
    private String name;
    private int id;
    private int age;
    public User(){}
    public User(String name, int id, int age){
        this.age = age;
        this.name = name;
        this.id = id;
    }

    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;
    }
}

5.2.Class 類

Class 本身也是一個類
Class 對象只能由系統建立對象
一個加載的類在 JVM 中只會有一個Class實例
一個Class對象對應的是一個加載到JVM中的一個.class文件
每個類的實例都會記得自己是由哪個 Class 實例所生成
通過Class可以完整地得到一個類中的所有被加載的結構
Class類是Reflection的根源，針對任何你想動態加載、運行的類，唯有先獲得相應的Class對象

Class 類常用方法：

5.3.獲取Class類的實例

若已知具體的類，通過類的class屬性獲取，該方法最為安全可靠，程序性能最高：Class clazz = Person.class;
已知某個類的實例，調用該實例的getClass()方法獲取Class對象：Class clazz = person.getClass();
已知一個類的全類名，且該類在類路徑下，可通過Class類的靜態方法forName()獲取，可能拋出ClassNotFoundException：Class clazz = Clazz.forName("demo01.Student");
內置基本數據類型可直接用類名.Type
還可以利用 ClassLoader

獲取Class類的方式

package reflection;
//測試 Class 類的創建方式
public class Test02 {
    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("reflection.Student");
        System.out.println(c2.hashCode());
        //方式三：類名.class 獲得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        //方式四：基本內置類型的包裝類都有一個Type屬性
        Class c4 = Integer.TYPE;
        System.out.println(c4);
        //獲得父類類型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}
class Person{
    String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }
}
class Student extends Person{
    public Student(){
        this.name = "學生";
    }
}
class Teacher extends Person{
    public Teacher(){
        this.name = "老師";
    }
}

5.4.哪些類型可以有 Class 對象

class：外部類，成員（成員內部類，靜態內部類），局部內部類，匿名內部類
interface：接口
[]：數組
enum：枚舉
annotation：注解@interface
primitive type：基本數據類型
void

各類型的Class對象

package reflection;

import java.lang.annotation.ElementType;

//所有類型的class
public class Test04 {
    public static void main(String[] args) {
        Class<Object> c1 = Object.class;//類
        Class<Comparable> c2 = Comparable.class;//接口
        Class<String[]> c3 = String[].class;//一維數組
        Class<int[][]> c4 = int[][].class;//二維數組
        Class<Override> c5 = Override.class;//注解
        Class<ElementType> c6 = ElementType.class;//枚舉
        Class<Integer> c7 = Integer.class;//基本數據類型
        Class<Void> c8 = void.class;//void
        Class<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);

        //只要元素類型與維度一樣，就是同一個class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

5.5.類的加載和初始化

類加載過程

package reflection;

public class Test05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);
        /*
        1.加載到內存，會產生一個類對應 class 對象
        2.鏈接，鏈接結束后，m=0
        3.初始化
            <clinit>(){
                System.out.println("A類靜態代碼初始化");
                m = 300;
                m = 100;
            }
        m = 100
         */
    }
}
class A{
    static {
        System.out.println("A類靜態代碼初始化");
        m = 300;
    }
    static int m = 100;
    public A(){
        System.out.println("A類的無參構造初始化");
    }
}

類的主動引用：一定會發生類的初始化

當虛擬機啟動，先初始化main方法所在的類
new一個類的對象
調用類的靜態成員（除了final常量）和靜態方法
使用java.lang.reflect包的方法對類進行反射調用
當初始化一個類，如果其父類沒有被初始化，則先會初始化它的父類
類的被動引用：不會發生類的初始化
當訪問一個靜態域時，只有真正聲明這個域的類才會被初始化。如：當通過子類引用父類的靜態變量，不會導致子類初始化
通過數組定義引用，不會觸發此類的初始化
引用常量不會觸發此類的初始化（常量在鏈接階段就存入調用類的常量池中了）

初始化

package reflection;
//測試類什么時候會初始化
public class Test06 {
    static {
        System.out.println("main類被加載");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主動引用
        //Son son = new Son();
        //反射也會產生主動引用
        //Class.forName("reflection.Son");

        //不會產生類的引用方法
        //System.out.println(Son.b);
        //Son[] array = new Son[5];
        //System.out.println(Son.M);
    }
}
class Father{
    static 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;

}

5.6.類加載器

rt.jar：根加載器
ext：擴展的加載器

加載器

package reflection;

public class Test07 {
    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++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //測試當前類是哪個加載器加載的
        ClassLoader classLoader = Class.forName("reflection.Test07").getClassLoader();
        System.out.println(classLoader);
        //測試JDK內置的類是誰加載的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

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

5.7.獲取運行時類的完整結構

獲取類信息

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//獲得類的信息
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("reflection.User");
        //獲得類的名字
        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);
        }
        //獲得指定屬性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //獲得類的方法
        Method[] methods = c1.getMethods();//獲得本類機器父類的所有public方法
        for (Method method : methods) {
            System.out.println("正常的："+method);
        }
        Method[] methods1 = c1.getDeclaredMethods();//獲得本類的所有方法
        for (Method method : methods1) {
            System.out.println("getDeclaredMethods"+method);
        }
        //獲得指定方法
        Method getName = c1.getDeclaredMethod("getName", null);
        System.out.println(getName);

        //獲得指定的構造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        //獲得指定的構造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
        System.out.println(declaredConstructor);
    }
}

6.反射操作泛型

ParameterizedType：表示一種參數化類型，比如Collection<String>
GenericArrayType：表示一種元素類型是參數化類型或者類型變量的數組類型
TypeVariable：是各種類型變量的公共父接口
WildcardType：代表一種通配符類型表達式

反射操作泛型

package 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 Test09 {
    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 = Test09.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#"+genericParameterType);
            if (genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }

            }
        }

        method = Test09.class.getMethod("test02");
        Type genericReturnType = method.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

7.反射操作注解

反射操作注解

package reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

//反射操作注解
public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("reflection.Student2");
        //通過反射獲得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //獲得注解的value的值
        TableStudent tableStudent = (TableStudent) c1.getAnnotation(TableStudent.class);
        String value = tableStudent.value();
        System.out.println(value);
        //獲得類指定的注解
        Field name = c1.getDeclaredField("name");
        FieldStudent annotation = name.getAnnotation(FieldStudent.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@TableStudent("db_student")
class Student2{
    @FieldStudent(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldStudent(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldStudent(columnName = "db_name",type = "varchar",length = 100)
    private String name;

    public Student2() {
    }

    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", 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;
    }
}
//類名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableStudent{
    String value();
}
//屬性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldStudent{
    String columnName();
    String type();
    int length();
}

posted @ 2024-05-15 16:08 落落的學習閱讀(23) 評論(0) 收藏舉報

刷新頁面返回頂部

luoluostudy