学习笔记-Java&kotlin注解&反射

哦哦哦哦哦
458 阅读6分钟

注解

注解是一种注释机制，注解是元数据的一种形式，提供有关 于程序但不属于程序本身的数据。注解对它们注解的代码的操作没有直接影响。

元注解

Java有四种元注解 @Target 、@Retention 、 @Documented 、 @Inherited
kotlin 同样也是四种元注解 @Target、@Retention、@Repeatable、@MustBeDocumented

Java 和 kotlin 中 @Target 和@Retention 作用是一样的

@Target

标记另一个注解，限制可以应用注解的类型，可选值：

Java

ElementType.ANNOTATION_TYPE 可以应用于注解类型。
ElementType.CONSTRUCTOR 可以应用于构造函数。
ElementType.FIELD 可以应用于字段或属性。
ElementType.LOCAL_VARIABLE 可以应用于局部变量。
ElementType.METHOD 可以应用于方法级注解。
ElementType.PACKAGE 可以应用于包声明。
ElementType.PARAMETER 可以应用于方法的参数。
ElementType.TYPE 可以应用于类的任何元素。

kotlin

AnnotationTarget.CLASS 类、接口、对象声明和注解类声明
AnnotationTarget.ANNOTATION_CLASS 其他注解类型声明
AnnotationTarget.TYPE_PARAMETER 通用类型参数（还不支持）。 AnnotationTarget.PROPERTY 属性声明
AnnotationTarget.FIELD 字段声明，包括属性的支持字段
AnnotationTarget.LOCAL_VARIABLE 局部变量声明
AnnotationTarget.VALUE_PARAMETER 用于函数或构造函数参数值声明
AnnotationTarget.CONSTRUCTOR 用于构造函数声明
AnnotationTarget.FUNCTION 用于函数声明，不包括构造函数
AnnotationTarget.PROPERTY_GETTER 只用于属性的getter访问器声明
AnnotationTarget.PROPERTY_SETTER 只用于属性的setter访问器声明
AnnotationTarget.TYPE 类型使用
AnnotationTarget.EXPRESSION 任何表达式
AnnotationTarget.FILE 文件
AnnotationTarget.TYPEALIAS 类型别名

@Retention

指定标记注解的存储方式

Java
RetentionPolicy.SOURCE 标记的注解仅保留在源码级别中，并被编译器忽略，编译之后会被丢弃。
APT ： 在编译期能够获取注解与注解声明的类包括类中所有成员信息，一般用于 IDE 语法检查，生成额外的辅助类等。
RetentionPolicy.CLASS 标记的注解在编译时由编译器保留，但 Java 虚拟机(JVM)会忽略。
字节码增强 ： 在编译出Class后，通过修改Class数据以实现修改代码逻辑目的。对于是否修改为不同逻辑的判断可以使用注解
RetentionPolicy.RUNTIME 标记的注解由 JVM 保留，因此运行时环境可以使用它。
反射 ： 在程序运行期间，通过反射技术动态获取注解与其元素，从而完成不同的逻辑判定

kotlin

AnnotationRetention.SOURCE 同Java RetentionPolicy.SOURCE 一样
AnnotationRetention.BINARY 同Java RetentionPolicy.CLASS 一样
AnnotationRetention.RUNTIME 同Java RetentionPolicy.RUNTIME 一样

@Documented

Java

用于被Javadoc 工具提取成文档

@Inherited

Java

允许子类继承父类中的注解。即拥有此注解的元素其子类可以继承父类的注解

@Repeatable

kotlin
允许在单个元素上多次使用相同的该注解。 只有@Retention 为 AnnotationRetention.SOURCE 时才可以使用 (注：查资料说是 在Java 8之前有这个限制，未测试)

@MustBeDocumented

kotlin

适用于文档注解，该注解可以修饰代码元素（类、接口、函数 和 属性等），文档生成工具可以提取这些注解信息。

反射

反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和 方法;对于任意一个对象,都能够调用它的任意方法和属性;并且能改变它的属性。是Java被视为动态语言的关键。

Java反射机制主要提供了以下功能：

  • 在运行时构造任何一个类的对象
  • 在运行时获取或者修改任意一个类所具有的成员变量和方法
  • 在运行时调用任意一个对象的方法（属性）

Class
class 是用来描述类的类，封装了当前对象所对应的类的信息。一个类中有属性，方法，构造器等。
一个类在 jvm 中只有一个 Class 实例

获得 Class 对象

  1. 获取Class对象的三种方式
  2. 通过对象获取 对象名.getClass()
  3. 通过全类名获取，Class.forName(全类名) classLoader.loadClass(全类名)
  • 使用 Class 类的 forName 静态方法
public static Class<?> forName(String className)
  • 直接获取某一个对象的 class
Class<?> clz = int.class; 
Class<?> clazInt = Integer.TYPE;
  • 调用对象的 getClass() 方法
Class<?> clz = "str".getClass();

判断是否为某个类的实例
isInstance() 用来判断是否为某个类的实例，或者说 clazz.isInstance(obj) obj 是否能强转为 clazz 类型。
obj instanceof clazz 判断 obj 是否是 clazz 这种类型
clazz.isAssignableFrom(clz) 判断 clazz 类是否和 clz 类相同或是 clz 的父类

创建实例

通过反射来生成对象主要有两种方式。

  • 使用 Class 对象的 newInstance() 方法来创建 Class对象对应类的实例。
String obj = String.class.newInstance();

先通过 Class 对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance() 方法来创建实例。这 种方法可以用指定的构造器构造类的实例

//获取String所对应的Class对象 
Class<?> str = String.class; 
//获取String类带一个String参数的构造器 
Constructor constructor = str.getConstructor(String.class); 
//根据构造器创建实例 
String obj = constructor.newInstance("string");

获取构造器信息 getConstructor() 方法

Constructor getConstructor(Class[] params)            //获得使用特定的参数类型的public构造函数(包括父类）
Constructor[] getConstructors()                       //获得类的所有公共构造函数 
Constructor getDeclaredConstructor(Class[] params)    //获得使用特定参数类型的构造函数(包括私有) 
Constructor[] getDeclaredConstructors()               //获得类的所有构造函数(与接入级别无关)

主要是通过过Class类的getConstructor方法得到Constructor类的一个实例，通过 constructor.newInstance() 方法可以创建一个对象实例。

获得字段信息的方法

Field getField(String name)             //根据字段名获取 public 字段
Field[] getFields()                     //获得所有 public 字段 
Field getDeclaredField(String name)     //根据字段名获取所有字段
Field[] getDeclaredFields()             //获得类声明的所有字段

调用方法

获得方法信息

Method getMethod(String name, Class[] params)  //根据方法名和参数获取 public 方法 
Method getMethods()   //  获取所有 public 方法
Method getDeclaredMethod(String name, Class[] params)   // 根据方法名和参数获取所有方法
Method getDeclaredMethods()  // 获取类的所有方法

获取到方法之后，可以使用 method.invoke() 执行方法。

利用反射创建数组

Array.newInstance()

反射获取泛型真实类型
反射获取泛型中的真实数据类型，需要 Type 完成，Type 接口包含了一个实现类(Class)和四个实现接口：
Type 接口是 java 中所有类型的公共高级接口。

  • TypeVariable
    泛型类型变量，描述类型，可以获得泛型上下限，类、方法或构造器名，泛型名称。
  • ParameterizedType
    泛型实例，泛型真实类型
  • GenericArrayType
    当需要描述的类型是泛型类的数组时，比如List[],Map[]，此接口会作为Type的实现
  • WildcardType
    通配符泛型，获得上下限信息

TypeVariable

public class TestType <K extends Comparable & Serializable, V> { 
    K key; 
    V value; 
    public static void main(String[] args) throws Exception { 
        // 获取字段的类型 
        Field fk = TestType.class.getDeclaredField("key"); 
        Field fv = TestType.class.getDeclaredField("value"); 
        
        //getGenericType()  获取属性的类型
        TypeVariable keyType = (TypeVariable)fk.getGenericType(); 
        TypeVariable valueType = (TypeVariable)fv.getGenericType(); 
        
        // getName 方法     返回泛型变量的名称
        System.out.println(keyType.getName());       // K 
        System.out.println(valueType.getName());     // V 
        
        // getGenericDeclaration 方法  返回声明泛型的类 
        System.out.println(keyType.getGenericDeclaration());        // class com.test.TestType
        System.out.println(valueType.getGenericDeclaration());      // class com.test.TestType 
        
        
        // getBounds 方法  返回泛型声明的边界
        System.out.println("K 的上界:"); // 有两个 
        for (Type type : keyType.getBounds()) {         // interface java.lang.Comparable 
            System.out.println(type);                   // interface java.io.Serializable 
        }
        System.out.println("V 的上界:"); 
        // 没明确声明上界的, 默认上界是 Object 
        for (Type type : valueType.getBounds()) { // class java.lang.Object 
            System.out.println(type); 
        } 
    } 
}

ParameterizedType

public class TestType { 
    Map<String, String> map; 
    public static void main(String[] args) throws Exception { 
    
        Field f = TestType.class.getDeclaredField("map"); 
        
        //getGenericType()  获取属性的类型
        System.out.println(f.getGenericType()); // java.util.Map<java.lang.String, java.lang.String> 
        
        ParameterizedType pType = (ParameterizedType) f.getGenericType();
        
        // getRawType  获取声明泛型的类  也就是 map
        System.out.println(pType.getRawType()); // interface java.util.Map 
        
        // getActualTypeArguments  获取泛型的实际类型
        for (Type type : pType.getActualTypeArguments()) { 
            System.out.println(type); // 打印两遍: class java.lang.String 
        } 
    } 
}

GenericArrayType

public class TestType { 
    List<String>[] lists; 
    public static void main(String[] args) throws Exception { 
    
        Field f = TestType.class.getDeclaredField("lists"); 
        
        //获取属性的类型
        GenericArrayType genericType = (GenericArrayType) f.getGenericType();  
        
        // getGenericComponentType()  返回泛型数组中元素的Type类型
        System.out.println(genericType.getGenericComponentType());    //java.util.List<java.lang.String>
    } 
}

WildcardType

public class TestType {
    private List<? extends Number> a; // 上限
    private List<? super String> b; //下限

    public static void main(String[] args) throws Exception {

        Field fa = TestType.class.getDeclaredField("a");
        Field fb = TestType.class.getDeclaredField("b");

        //获取泛型类型
        ParameterizedType pa = (ParameterizedType) fa.getGenericType();
        ParameterizedType pb = (ParameterizedType) fb.getGenericType();

        System.out.println(fa.getGenericType());        // java.util.List<? extends java.lang.Number>
        System.out.println(fb.getGenericType());        // java.util.List<? super java.lang.String>

        //从泛型获取通配符类型
        WildcardType wa = (WildcardType) pa.getActualTypeArguments()[0];
        WildcardType wb = (WildcardType) pb.getActualTypeArguments()[0];

        System.out.println(wa);         // ? extends java.lang.Number
        System.out.println(wb);         // ? super java.lang.String

        /**
         * getUpperBounds &  getLowerBounds
         * 获取泛型通配符的上下限
         */
        System.out.println(wa.getUpperBounds()[0]);     // class java.lang.Number
        System.out.println(wb.getLowerBounds()[0]);     // class java.lang.String
    }

}
avatar
文章
阅读
粉丝