【04】Java语言高级特性注解与反射

最新推荐文章于 2024-06-21 19:23:49 发布

清风百草

最新推荐文章于 2024-06-21 19:23:49 发布

阅读量199

点赞数

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qinyunying/article/details/108628670

版权

【90】Android中的Java核心技术专栏收录该内容

35 篇文章 0 订阅

订阅专栏

（1）一个人只要自己不放弃自己，整个世界也不会放弃你.
（2）天生我才必有大用
（3）不能忍受学习之苦就一定要忍受生活之苦，这是多么痛苦而深刻的领悟.
（4）做难事必有所得
（5）精神乃真正的刀锋
（6）战胜对手有两次，第一次在内心中.
（7）好好活就是做有意义的事情.
（8）亡羊补牢，为时未晚
（9）科技领域，没有捷径与投机取巧。
（10）有实力，一年365天都是应聘的旺季，没实力，天天都是应聘的淡季。
（11）基础不牢，地动天摇
（12）写博客初心：成长自己，辅助他人。当某一天离开人世，希望博客中的思想还能帮人指引方向.
（13）编写实属不易，若喜欢或者对你有帮助记得点赞+关注或者收藏哦~

Java语言高级特性注解与反射

1.Java语言的重要性

Java知识是作为Android开发的语言基础，虽然现在已经推出了kotlin，但是基于以下原因我们还是需要好好牢牢掌握java。

（1）SDK还是java，kotlin也需要编译成为java运行；

（2）Java语言应用不仅仅在Android，就是在后台开发中也是一个最流行的语言；

（3）大公司面试都要求我们有扎实的Java语言基础。

2.注解

（1）Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。

（2）注解是元数据的一种形式，提供有关于程序但不属于程序本身的数据。

（3）注解对它们注解的代码的操作没有直接影响。

2.1注解声明

2.1.1声明一个注解类型

（1）Java中所有的注解，默认实现Annotation 接口


public interface Annotation {
    boolean equals(Object var1);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}

（2）与声明一个"Class"不同的是，注解的声明使用@interface 关键字。一个注解的声明如下

public @interface Lance{

}

2.1.2元注解

（1）在定义注解时，注解类也能够使用其他的注解声明。

（2）对注解类型进行注解的注解类，我们称之为 metaannotation（元注解）。

（3）一般的，我们在定义自定义注解时，需要指定的元注解有两个：

@Documented 元注解：用于被javadoc工具提取成文档。
@Inherited 元注解：表示允许子类继承父类中定义的注解。

2.1.2.1@Target

（1）注解标记另一个注解，以限制可以应用注解的 Java 元素类型。

（2）目标注解指定以下元素类型之一作为其值：

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

2.1.2.2 @Retention

（1）注解指定标记注解的存储方式：

RetentionPolicy.SOURCE - 标记的注解仅保留在源级别中，并被编译器忽略。
RetentionPolicy.CLASS - 标记的注解在编译时由编译器保留，但 Java 虚拟机(JVM)会忽略。
RetentionPolicy.RUNTIME - 标记的注解由 JVM 保留，因此运行时环境可以使用它。

（2）@Retention 三个值中 SOURCE < CLASS < RUNTIME，即CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。下文会介绍他们不同的应用场景。

（3）下面来看例子：

//@Target(ElementType.TYPE) 只能在类上标记该注解
@Target({ElementType.TYPE,ElementType.FIELD}) // 允许在类与类属性上标记该注解
@Retention(RetentionPolicy.SOURCE) //注解保留在源码中
public @interface Lance {
}

2.1.3注解类型元素

（1）在上文元注解中，允许在使用注解时传递参数。

（2）我们也能让自定义注解的主体包含 annotation type element (注解类型元素) 声明，它们看起来很像方法，可以定义可选的默认值。

@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.SOURCE)
public @interface Lance {
String value(); //无默认值
int age() default 1; //有默认值
}

（3）注意：在使用注解时，如果定义的注解中的类型元素无默认值，则必须进行传值。

//如果只存在value元素需要传值的情况，则可以省略:元素名=
@Lance("帅") 
@Lance(value="帅",age = 2)
int i;

3.注解应用场景

按照@Retention 元注解定义的注解存储方式，注解可以被在三种场景下使用：

3.1SOURCE

（1）RetentionPolicy.SOURCE ，作用于源码级别的注解，可提供给IDE语法检查、APT等场景使用。

在这里插入图片描述

（2）在类中使用SOURCE 级别的注解，其编译之后的class中会被丢弃。

在这里插入图片描述

3.1.1IDE语法检查

（1）在Android开发中， support-annotations 与androidx.annotation) 中均有提供@IntDef 注解，此注解的定义如下：

@Retention(SOURCE) //源码级别注解
@Target({ANNOTATION_TYPE})
public @interface IntDef {
    int[] value() default {};
    boolean flag() default false;
    boolean open() default false;
}

（1）Java中Enum(枚举)的实质是特殊单例的静态成员变量，在运行期所有枚举类作为单例，全部加载到内存中。比常量多5到10倍的内存占用。

（2）此注解的意义在于能够取代枚举，实现如方法入参限制。

（3）如：我们定义方法test ，此方法接收参数teacher 需要在：Lance、Alvin中选择一个。如果使用枚举能够实现为:


public enum Teacher{
	LANCE,ALVIN
}

public void test(Teacher teacher) {

}

（2）而现在为了进行内存优化，我们现在不再使用枚举，则方法定义为：

public static final int LANCE = 1;
public static final int ALVIN = 2;

public void test(int teacher) {

}

（3）然而此时，调用test 方法由于采用基本数据类型int，将无法进行类型限定。此时使用@IntDef增加自定义注解：

public static final int LANCE = 1;
public static final int ALVIN = 2;

@IntDef(value = {MAN, WOMEN}) //限定为LANCE，ALVIN
@Target(ElementType.PARAMETER) //作用于参数的注解
@Retention(RetentionPolicy.SOURCE) //源码级别注解
public @interface Teacher {

}
public void test(@Teacher int teacher) {

}

（4）此时，我们再去调用test 方法，如果传递的参数不是LANCE 或者ALVIN 则会显示 Inspection 警告(编译不会报错)。

在这里插入图片描述

（5）可以修改此类语法检查级别：

在这里插入图片描述

（6）以上注解均为SOURCE 级别，本身IDEA/AS 就是由Java开发的，工具实现了对Java语法的检查，借助注解能对被注解的特定语法进行额外检查。

3.1.2APT注解处理器

（1）APT全称为：“Anotation Processor Tools”，意为注解处理器。顾名思义，其用于处理注解。

（2）编写好的Java源文件，需要经过javac 的编译，翻译为虚拟机能够加载解析的字节码Class文件。

（3）注解处理器是 javac 自带的一个工具，用来在编译时期扫描处理注解信息。

（4）你可以为某些注解注册自己的注解处理器。注册的注解处理器由javac调起，并将注解信息传递给注解处理器进行处理。

注解处理器是对注解应用最为广泛的场景。在Glide、EventBus3、Butterknifer、Tinker、ARouter等等常用。
框架中都有注解处理器的身影。但是你可能会发现，这些框架中对注解的定义并不是SOURCE 级别，更多的是CLASS 级别，别忘了：CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。

3.2CLASS

（1）定义为CLASS 的注解，会保留在class文件中，但是会被虚拟机忽略(即无法在运行期反射获取注解)。此时完全符合此种注解的应用场景为字节码操作。如：AspectJ、热修复Roubust中应用此场景。

（2）所谓字节码操作即为，直接修改字节码Class文件以达到修改代码执行逻辑的目的。

（3）在程序中有多处需要进行是否登录的判断。

在这里插入图片描述

（1）如果我们使用普通的编程方式，需要在代码中进行if-else 的判断，也许存在十个判断点，则需要在每个判断点加入此项判断。

（2）此时，我们可以借助AOP(面向切面)编程思想，将程序中所有功能点划分为：需要登录与无需登录两种类型，即两个切面。对于切面的区分即可采用注解。

//Java源代码
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface Login {

}

@Login
public void jumpA(){
	startActivity(new Intent(this,AActivity.class));
}

public void jumpB(){
	startActivity(new Intent(this,BActivity.class));
}

（1）在上诉代码中， jumpA 方法需要具备登录身份。而Login 注解的定义被设置为CLASS 。因此我们能够在该类所编译的字节码中获得到方法注解Login 。

（2）在操作字节码时，就能够根据方法是否具备该注解来修改class中该方法的内容加入if-else 的代码段：

//Class字节码
@Login
public void jumpA() {
    if (this.isLogin) {
    	this.startActivity(new Intent(this, LoginActivity.class));
    } else {
    	this.startActivity(new Intent(this, AActivity.class));
    }
}

public void jumpB() {
	startActivity(new Intent(this,BActivity.class));
}

（3）注解能够设置类型元素(参数)，结合参数能实现更为丰富的场景，如：运行期权限判定等。

3.3RUNTIME

（1）注解保留至运行期，意味着我们能够在运行期间结合反射技术获取注解中的所有信息。

4.反射

（1）一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的，并且能够获得此类的引用。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。

（2）反射则是一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。这时候，我们使用 JDK 提供的反射 API 进行反射调用。

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

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

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

4.1Class

（1）反射始于Class，Class是一个类，封装了当前对象所对应的类的信息。

（2）一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是Class，它应该有类名，属性，方法，构造器等。

（3）Class是用来描述类的类。

（4）Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。

（5）对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。

（6）对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例。

4.2获得 Class 对象

（1）通过类名获取类名.class
（2）通过对象获取对象名.getClass()
（3）通过全类名获取 Class.forName(全类名) classLoader.loadClass(全类名)

使用 Class 类的 forName 静态方法

public static Class<?> forName(String className)

直接获取某一个对象的 class

Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

调用某个对象的 getClass() 方法

StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

4.3判断是否为某个类的实例

（1）一般地，我们用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中 Class 对象的isInstance() 方法来判断是否为某个类的实例，它是一个 native 方法：

public native boolean isInstance(Object obj);

（2）判断是否为某个类的类型

public boolean isAssignableFrom(Class<?> cls)

4.4创建实例

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

使用Class对象的newInstance()方法来创建Class对象对应类的实例。

Class<?> c = String.class;
Object str = c.newInstance();

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

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

4.5获取构造器信息

得到构造器的方法

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

4.6获取类的成员变量（字段）信息

获得字段信息的方法

Field getField(String name) -- 获得命名的公共字段
Field[] getFields() -- 获得类的所有公共字段
Field getDeclaredField(String name) -- 获得类声明的命名的字段
Field[] getDeclaredFields() -- 获得类声明的所有字段

4.7调用方法

（1）获得方法信息的方法

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
Method[] getMethods() -- 获得类的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法
Method[] getDeclaredMethods() -- 获得类声明的所有方法

（2）当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。invoke 方法的原型为:

public Object invoke(Object obj, Object... args)

4.8利用反射创建数组

（1）数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference 其中的Array类为
java.lang.reflect.Array类。

（2）我们通过Array.newInstance()创建数组对象，它的原型是:


public static Object newInstance(Class<?> componentType, int length);

4.9反射获取泛型真实类型

（1）当我们对一个泛型类进行反射时，需要得到泛型中的真实数据类型，来完成如json反序列化的操作。此时需要通过Type 体系来完成。Type 接口包含了一个实现类(Class)和四个实现接口，他们分别是：

TypeVariable
泛型类型变量。可以泛型上下限等信息；
ParameterizedType
具体的泛型类型，可以获得元数据中泛型签名类型(泛型真实类型)
GenericArrayType
当需要描述的类型是泛型类的数组时，比如List[],Map[]，此接口会作为Type的实现。
WildcardType
通配符泛型，获得上下限信息；

4.9.1TypeVariable

package com.annotations.class1.test;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

public class TestType <K extends Comparable & Serializable,V> {
    K key;
    V value;

    public static void main(String[] args) throws NoSuchFieldException {
        //s1.获取字段类型
        Field fk = TestType.class.getDeclaredField("key");
        Field fv = TestType.class.getDeclaredField("value");

        //s2.获取泛型类型
        TypeVariable keyType = (TypeVariable) fk.getGenericType();
        TypeVariable valueType = (TypeVariable) fv.getGenericType();

        //s3.getName打印变量名
        System.out.println(keyType.getName());
        System.out.println(valueType.getName());

        //s4.getGenericDeclaration获取泛型声明
        System.out.println(keyType.getGenericDeclaration());
        System.out.println(valueType.getGenericDeclaration());

        //s5.getBounds()方法
        System.out.println("K的上界:");
        for(Type type : keyType.getBounds()){
            System.out.println(type);
        }

        System.out.println("V的上界:");
        for(Type type : valueType.getBounds()){
            System.out.println(type);
        }
    }
}

运行结果:

K
V
class com.annotations.class1.test.TestType
class com.annotations.class1.test.TestType
K的上界:
interface java.lang.Comparable
interface java.io.Serializable
V的上界:
class java.lang.Object

4.9.2ParameterizedType

（1）案例

package com.annotations.class1.test;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;

public class TestType1 {
    Map<String,String> map;

    public static void main(String[] args) throws Exception {
        //s1.获取指定字段
        Field field = TestType1.class.getDeclaredField("map");
        //s2.输出字段的泛型类型
        System.out.println(field.getGenericType());
        //s3.获取字段的泛型类型
        ParameterizedType pType = (ParameterizedType) field.getGenericType();
        //s4.获取泛型类型的实际类型
        System.out.println(pType.getRawType());
        //s5.获取字段的泛型类型的参数类型
        for(Type type : pType.getActualTypeArguments()){
            System.out.println(type);
        }
    }
}

（2）运行结果

java.util.Map<java.lang.String, java.lang.String>
interface java.util.Map
class java.lang.String
class java.lang.String

4.9.3GenericArrayType

（1）案例

package com.annotations.class1.test;

import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.util.List;

public class TestType2<T> {

    List<String>[] lists;

    public static void main(String[] args) throws NoSuchFieldException {
        //s1.获取字段
        Field f = TestType2.class.getDeclaredField("lists");
        //s2.获取泛型数组类型
        GenericArrayType genericArrayType = (GenericArrayType) f.getGenericType();
        //s3.获取泛型数组元素类型
        System.out.println(genericArrayType.getGenericComponentType());
    }
}

（2）运行结果

java.util.List<java.lang.String>

4.9.4WildcardType

（1）案例代码

package com.annotations.class1.test;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.WildcardType;
import java.util.List;

public class TestType3 {
    //s1.泛型上界限定
    private List<? extends Number> a;

    //s2.泛型下界限定
    private List<? super Number> b;

    public static void main(String[] args) throws NoSuchFieldException {
        //s1.得到字段
        Field fieldA = TestType3.class.getDeclaredField("a");
        Field fieldB = TestType3.class.getDeclaredField("b");

        //s2.获取泛型类型
        ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType();
        ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType();

        //s3.从泛型中拿到通配符类型
        WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
        WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0];

        //s4.测试方法
        System.out.println(wTypeA.getUpperBounds()[0]);
        System.out.println(wTypeB.getLowerBounds()[0]);

        //s5.查看通配符类型到底是什么
        System.out.println(wTypeA);

    }
}

（2）运行结果

class java.lang.Number
class java.lang.Number
? extends java.lang.Number

4.9.5Gson反序列化

static class Response<T> {
    T data;
    int code;
    String message;
    
    @Override
    public String toString() {
        return "Response{" +
        "data=" + data +
        ", code=" + code +
        ", message='" + message + '\'' +
        '}';
    }
    
    public Response(T data, int code, String message) {
        this.data = data;
        this.code = code;
        this.message = message;
    }
}

static class Data {
	String result;
	
    public Data(String result) {
        this.result = result;
    }
    
    @Override
    public String toString() {
        return "Data{" +
        "result=" + result +
        '}';
    }
}

public static void main(String[] args) {
	Response<Data> dataResponse = new Response(new Data("数据"), 1, "成功");
    Gson gson = new Gson();
    String json = gson.toJson(dataResponse);
    System.out.println(json);

//为什么TypeToken要定义为抽象类？
    Response<Data> resp = gson.fromJson(json, new TypeToken<Response<Data>>() {
    }.getType());
	System.out.println(resp.data.result);
}

（1）在进行GSON反序列化时，存在泛型时，可以借助TypeToken 获取Type以完成泛型的反序列化。但是为什么TypeToken 要被定义为抽象类呢？

（2）因为只有定义为抽象类或者接口，这样在使用时，需要创建对应的实现类，此时确定泛型类型，编译才能够将泛型signature信息记录到Class元数据中。

5.打赏鼓励

感谢您的细心阅读，您的鼓励是我写作的不竭动力！！！

5.1微信打赏

在这里插入图片描述

5.2支付宝打赏

在这里插入图片描述

清风百草

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【04】Java语言高级特性注解与反射

（1）一个人只要自己不放弃自己，整个世界也不会放弃你.（2）天生我才必有大用（3）不能忍受学习之苦就一定要忍受生活之苦，这是多么痛苦而深刻的领悟.（4）做难事必有所得（5）精神乃真正的刀锋（6）战胜对手有两次，第一次在内心中.（7）编写实属不易，若喜欢或者对你有帮助记得点赞+关注或者收藏哦~Java语言高级特性注解与反射文章目录Java语言高级特性注解与反射1.Java语言的重要性2.注解2.1注解声明2.1.1声明一个注解类型2.1.2元注解2.1.2.1@Target2.1.2.2 .
复制链接

扫一扫