Java注解和反射的理解

最新推荐文章于 2022-11-05 23:46:47 发布
最新推荐文章于 2022-11-05 23:46:47 发布
阅读量383 收藏 1
点赞数 3
分类专栏： Java进阶 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44766232/article/details/118394995
版权

Java注解与反射

注解定义

先来看看网上的解释：

注解是标记，也可以理解成是一种应用在类、方法、参数、属性、构造器上的特殊修饰符。注解作用有以下三种：

第一种：生成文档，常用的有@param@return等。

第二种：替代配置文件的作用，尤其是在spring等一些框架中，使用注解可以大量的减少配置文件的数量。

第三种：检查代码的格式，如@Override，标识某一个方法是否覆盖了它的父类的方法。

简单来说，Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。 注解是元数据的一种形式，提供有关于程序但 不属于 程序本身的数据。注解对它们注解的代码的操作没有直接影响。

看一个 JDK 内置注解的定义：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {

}

注意 Annotation 接口中的描述：

The common interface extended by all annotation types

所以上述 Override 本质上可以写成：

public interface Override extends Annotation{}

注解本质上是一种特殊的注释，编译器在解析类、对象或者方法的注释时会检查某个类或者方法有没有被一些注解修饰，检查有没有注解，有的话就会处理注解

注解分为编译器已熟悉的注解类 + 我们自定义的注解类，当遇到我们自定义的注解类的时候，编译器有可能不知道怎么处理，所以会根据该注解的生命周期和对象范围来判断要不要编译进字节码文件

字节码文件：

注解声明

总结：Java 中所有的注解，默认实现 Annotation 接口，注解也就是一个继承了Annotation 接口的接口

package java.lang.annotation;
public interface Annotation{
	boolean equals(Object obj);
	
	int hashCode();

	String toString();
	
	Class<? extends Annotation> annotationType();
}

注解声明与普通类 “class” 不同点在注解用 @interface 关键字，例：

public @interface XY{
}

元注解

自定义注解：

定义注解的注解，准确讲就是对 注解类型 进行注解的 注解类，定义为 meta-annotation

自定义元注解有四类：（主要用 @Target \ @Retention ）

  • @Target：注解的作用目标
  • @Retention：注解的生命周期
  • @Documented：注解是否应当被包含在 JavaDoc 文档中
  • @Inherited：是否允许子类继承该注解
@Traget

@Trage 用于注解标记另一个注解，作用于限制下文注解类中可以注解的 Java 元素类型。

翻译：作用于指定注解谁，告诉编译器，你写的注解类是给方法、字段属性还是类。

定义：

@Documented
@Retention(RETENTIONpOLICY.Runtime)
@Target(ElemenType.ANNOTATION_TYPE)
public @interface Target{
	ElementType[] XY();
}

赋值语句：@Target(value = {ElementType.FIELD})

注意 ElementType 是一个枚举类型，值有下列:

  • ElementType.TYPE：注解作用在类、接口和枚举上
  • ElementType.FIELD：用于字段或属性
  • ElementType.METHOD：用于方法
  • ElementType.PARAMETER：用于方法的参数
  • ElementType.CONSTRUCTOR：用于构造函数
  • ElementType.LOCAL_VARIABLE：用于本地局部变量
  • ElementType.ANNOTATION_TYPE：用于注解
  • ElementType.PACKAGE：用于包声明
@Retention

@Retention的解释是告诉编译器注解的 生命周期 ，也就是该注解可以存在到什么时候，一共有三种：

  • RetentionPolicy.SOURCE - 标记的注解仅保留在源级别中，并被编译器忽略，不会写入 .class 文件
  • RetentionPolicy.CLASS - 标记的注解在编译时由编译器保留，但 Java 虚拟机( JVM)会忽略，会写入 .class 文件
  • RetentionPolicy.RUNTIME - 标记的注解由 JVM 保留，因此运行时环境可以使用它，永久保存，多用于反射
  • @Documented 注解修饰的注解 - 是否要保存到 JavaDox 文档中（打包时候）
  • @Inherited - 该类的子类将自动继承父类的该注解

@Retention 三个值中 SOURCE < CLASS < RUNTIME，即CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS

定义：

//@Target(ElementType.TYPE) 只能在类上标记该注解

@Target({ElementType.TYPE,ElementType.FIELD}) // 允许在类与类属性上标记该注解TYPE是类,FIELD是字段或属性，
//意思就是注解只用于下面是这两种的身上，可以实一个或者多个
@Retention(RetentionPolicy.SOURCE) //注解保留在源码中，只存在源码中，一编译就会被忽略
public @interface Lance {

}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention{
	RetentionPolicy value();
}

赋值语句：@Retention(RetentionPolicy.SOURCE)
注意：RetentionPolicy 依然是一个枚举类型

内置三大注解：

JDK预定义注解：

  • @Override
  • @Deprecated
  • @SuppressWarnings
@Override

定义：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

没有任何的属性，并不能存储任何其他信息。只能作用于方法之上，编译结束后丢弃
是一种典型的『标记式注解』，仅被编译器可知，编译器在对 java 文件进行编译成字节码的过程中，一旦检测到某个方法上被修饰了该注解，就会去匹对父类中是否具有一个同样方法签名的函数，如果不是，则不能通过编译

@Deprecated

定义：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {CONSTRUCTOR,FIELD,LOCAL_VARIABLE,
					METHOD,PACKAGE,PARAMETER,TYPE
				})
public @interface Deprecated{
}

定义为标记式注册，生命周期为永久存在，作用于所有类型，用于标记当前类、方法或字段已不被推荐使用，JDK更新后就被删除
只作提醒作用，建议更新当前类型

@SuppressWarnings
@Target({TYPE,FIELD,METHOD,PATAMETER,
		CONSTUCTOR,LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOUCE)
public @interface SuppressWarnings{
	String[] value();
}

注意：value 要被传值，表示需要被压制的警告类型:

public static void main(String[] args)}{
	Data data = new Data(2018,7,11) //过时代码
}

这段代码报错：

Warning:(8, 21) java: java.util.Date 中的 Date(int,int,int) 已过时

若是在编译器检查代码中过时方法时，你不要程序启动可使用 @SuppressWarnings 注解并给它的 value 属性传入一个参数值来压制编译器的检查

@SuppressWarning(value = "deprecated")
public static void main(String[] args) {
    Date date = new Date(2018, 7, 11);
}

注解类型元素

在元注解中，允许使用注解时传递参数，也可以让自定义注解的 主体 包含 Annotation TYPE Element(注解类型元素)声明，看起来像普通的方法，可以定义可选的默认值

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

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

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

注解应用场景

SOURCE

SOURCE用于两点： IDE语法检查 + APT注解处理器

IDE语法检查：

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

这里的support - annotations 和 androidx.annotation 是包

问题：

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

现在用注解取代枚举，实现像方法入参限制

定义方法 accept ，用于接受参数 why ，需要在 HYQ, WSQ 中选择一个

若是用枚举实现：

public enum{
	why{ HYQ, WSQ }
}
public void accept(Teacher teacher){
}

枚举类型一个成员对象占用 12 + 成员 个字节，并且同时进行8字节对齐，忒占内存
内存优化做法，不用枚举，方法定义为：

public static final int HYQ = 1; 
public static final int WSQ = 2;

public void accept(int why) {
}

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

public static final int HYQ = 1; 
public static final int WSQ = 2;

@IntDef(value = {MAN, WOMEN}) //限定为WSQ，HYQ 
@Target(ElementType.PARAMETER) //作用于参数的注解
@Retention(RetentionPolicy.SOURCE) //注解留在源码
public @interface accept{
}

public void accept(@why int why) {

}

最后调用 test 方法，如果传递的参数不是 HYQ 或者 WSQ 的化就会显示 Inspection 警告（但编译不会报错）：
在这里插入图片描述
想不报错修改语法检查级别就好

APT注解处理器：

来看看APT注解处理器的解释：

APT全称为：“Annotation Processor Tools”，意为注解处理器。顾名思义，其用于处理注解。编写好的Java源文件，需要经过 javac 的编译，翻译为虚拟机能够加载解析的字节码Class文件。注解处理器是 javac 自带的一个工具，用来在编译时期扫描处理注解信息。 你可以为自己写的注解注册自己的注解处理器 。 注册的注解处理器由 javac 调起，并将注解信息传递给注解处理器进行处理。

另外加多两点：

注解处理器是对注解应用最为广泛的场景。在Glide、EventBus3、Butterknifer、Tinker、ARouter等等常用

框架中都有注解处理器的身影。但是你可能会发现，这些框架中对注解的定义并不是 是 CLASS 级别，别忘了：CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。

CLASS

定义为 CLASS 的注解，会保留在class文件中，但是会被虚拟机忽略(即无法在运行期反射获取注解)。此时完全符合此种注解的应用场景为字节码操作。如：AspectJ、热修复Roubust中应用此场景。
所谓字节码操作即为，直接修改字节码Class文件以达到修改代码执行逻辑的目的。在程序中有多处需要进行是否登录的判断。
在这里插入图片描述
如果我们使用普通的编程方式，需要在代码中进行 的判断，也许存在十个判断点，则需要在每个判断点加
入此项判断。此时，我们可以借助 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));
}

在上诉代码中， jumpA 方法需要具备登录身份。而 注解的定义被设置为 CLASS 。因此我们能够在该类所编
译的字节码中获得到方法注解 Login 。在操作字节码时，就能够根据方法是否具备该注解来修改class中该方法的

内容加入 的代码段：

//Class字节码
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));
}

(注意上面是class字节码不是源码)

RUNTIME

注解保留到运行期间，大多数情况用于在运行期间结合 反射技术 获取注解中的所有信息

反射

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

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

反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法

对于任意一个对象,都能够调用它的任意方法和属性

并且能改变它们的属性。是Java被视为动态语言的关键

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

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

什么是反射和什么是反射Class

反射始于Class，Class是一个类，封装了当前对象 所对应的类的信息。一个类中有属性，方法，构造器等

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

Class(试着看成是个别名)

引用一下：
Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。对于每个普通类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。 对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例（这一段我也看不懂）

获取class对象

获取Class对象的三种方式

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

判断是否为某个类的实例

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

public native boolean isInstance(Object obj);

判断是否为某个类的类型

public boolean isAssignableFrom(Class<?> cls)

创建实例

利用反射技术实现创建对象有两种方法：

  1. 使用Class对象的newInstance()方法来创建Class对象对应类的实例。
Class<?> c = String.class;
Object str = c.newInstance();
  1. 先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例
//获取 String 所对应的 Class 对象
Class<?> c = String.class;

//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);

//根据构造器创建实例
Object obj = constructor.newInstance("123");
System.out.println(obj);

获取构造器信息

得到构造器的方法

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

获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的 一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例:

public T newInstance(Object ... initargs)

获取类的成员变量

获得字段信息的方法

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

调用方法

获得方法信息的方法

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

从类中获取了一个方法后，我们就可以用 incoke() 方法来调用这个方法。

invoke() 方法的原型为:

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

利用反射创建数组

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference 其中的Array类为
java.lang.reflect.Array类。我们通过**Array.newInstance()**创建数组对象，它的原型是:

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

反射获取泛型真实类型

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

  • 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");

			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");
		System.out.println(f.getGenericType()); 
		//java.util.Map<java.lang.String,java.lang.String>
		ParameterizedType pType = (ParameterizedType) f.getGenericType(); 		
		System.out.println(pType.getRawType());	// interface java.util.Map 
		for (Type type : pType.getActualTypeArguments()) {
			System.out.println(type);	// 打印两遍: class java.lang.String
		}
	}
}

GenericArrayType

public class TestType<T> { 
	List<String>[] lists;
	
	public static void main(String[] args) throws Exception { 
		Field f = TestType.class.getDeclaredField("lists");
		GenericArrayType genericType = (GenericArrayType) f.getGenericType(); 	
		System.out.println(genericType.getGenericComponentType());
	}
}

WildcardType

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

	public static void main(String[] args) throws Exception { 
	Field fieldA = TestType.class.getDeclaredField("a"); 
	Field fieldB = TestType.class.getDeclaredField("b");
	// 先拿到范型类型
	ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType(); 
	ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType();
	// 再从范型里拿到通配符类型
	WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0]; 
	WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0];
	// 方法测试
	System.out.println(wTypeA.getUpperBounds()[0]);	// class java.lang.Number 
	System.out.println(wTypeB.getLowerBounds()[0]);	// class java.lang.String
	// 看看通配符类型到底是什么, 打印结果为: ? extends java.lang.Number
	System.out.println(wTypeA);
	}
}

Gson反序列化

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

在进行GSON反序列化时，存在泛型时，可以借助 TypeToken 获取 Type 以完成泛型的反序列化。
TypeToken 要被定义为抽象类是因为：只有定义为抽象类或者接口，这样在使用时，需要创建对应的实现类，此时确定泛型类型，编译才能够将泛型 signature 信息记录到 Class 元数据中。

---------------郭氏王氏何氏

何义竏
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java注解与反射
Sun_study的博客
02-06 288
一、注解（Annotation） 注解（也被称为元数据）为我们在代码中添加信息提供了一种形式化的方法，是我们可以在稍后某个时刻非常方便地使用这些元数据。 注解的定义看起来很像接口的定义。与其他Java接口一样，注解也将会编译成class文件。 内置注解 @Override 表示当前的方法定义将覆盖超类中的方法。 @Deprecated 在使用一些方法时会出现横线。表示废弃，这个注释可以修辞方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为他很危险或有更好的选择 @SuperWarnin
JAVA基础之注解和反射
王文强
01-17 539
介绍需要掌握的基础知识中的注解和反射相关内容
Java反射和注解简介
weixin_42786301的博客
11-05 423
Java反射和注解简介
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1147
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java基础-注解和反射
09-11
从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有...
java基础的注解和反射的相关知识点总结
09-06
，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记 反射和反射机制 反射(Reflection)： Java的反射是指程序在运行期可以拿到一个对象的所有信息。 反射的优点和缺点： 优点：可以实现动态创建对象...
Java 注解
12-22
提到注解，我们会不由的想到注释，其实注解和注释不是一个东西，注释的作用就是解释代码，方便理解和阅读，说白了就是给程序员看的。而注解则不是，注解的作用比较大，可以进行编译检查、生成doc文档或者进行代码...
Java基础语法测试-基础数据类型-注解-数组-inet-反射-oop-Java代码实现
最新发布
03-09
内容概要：通过带着读者编写Java基础语法测试代码，理解基础数据类型-注解-数组-inet-反射-oop-Java代码实现过程和测试代码 适合人群：初学java语法入门测试代码 能学到什么：①注解、数组、数据类型、inet、method...
注解+自定义注解+元注解+理解
02-26
注解+自定义注解+元注解+理解 - 本资源是一个注解的理解，解释了注解的作用和分类，以及如何用Java创建和使用自定义注解，包括使用元注解，反射，处理器等。
java 反射和注解
weixin_41765786的博客
07-19 1128
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
注解、反射的简单理解
qq_52469048的博客
10-16 184
元注解是用于定义注解的注解，包括@Retention、@Target、@Inherited、@Documented、@Repeatable 等。2.程序运行时，获取类的完整结构信息，如方法、属性、注解等，还能执行方法和修改属性。1.反射对应的类是Class 类，每个类型对应唯一一个Class 对象，即反射对象。元注解也是Java自带的标准注解，只不过用于修饰注解，比较特殊。1.使用类的class属性来获取该类对应的Class对象。2.简洁的方式，给程序提供强大的功能和灵活性，提高开发效率。
注解和反射的理解
qq_45790350的博客
06-30 307
反射 Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。==> 本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。 Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。 通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。 在运行时期，一个类只有一个Class
Java 注解和反射详解
Woo_home的博客
09-15 3104
文章目录注解什么是注解？内置注解元注解@Target@Retention@Documented@Inherited自定义注解反射静态语言 VS 动态语言动态语言静态语言Java 反射机制概述Java 反射机制提供的功能Java 反射优点和缺点反射相关的主要 API理解 Class 类并获取 Class 实例Class 类Class 类的常用方法获取 Class 类的实例所有类型的 Class 对象Java 内存分析类的加载与 ClassLoader 的理解 注解 什么是注解？ Annotation 是从
java注解和反射原理_深度剖析！注解及反射的使用的底层原理，看完没有不懂的！...
weixin_28697603的博客
02-16 416
前言注解(Annotation)又称Java标注，是 JDK5.0 引入的一种注释机制。Java 语言中的类、方法、变量、参数和包等都可以被标注，和 Javadoc(也就是所说的文档注释) 不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义Java 标注。上面这个太...
java注解和反射原理_java基础系列(三):注解和反射详解
weixin_28744573的博客
02-13 498
一，java注解1.什么是java注解？注解(Annotation)是从jdk5.0引入的技术，可以被其他的程序读取，可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，通过反射机制可以实现对这些元数据的访问。2.元注解java定义了4个标准的meta-annotation类型，这些类型和他们所支持的类在java.lang.annotation包...
Retrofit中的注解反射与动态代理
soulli的专栏
03-07 595
注解的应用场景 1.源码：APT注解处理器 Annotatino Processing Tool, 作用是处理代码中的注解, 用来生成代码, 用代码生成代码的工具。 2.字节码：字节码增强 打开运行时JVM的钥匙，动态代理 、AOP也与字节码增强有关。 3.运行时：反射 是java被视为动态语言的关键 ...
注解的应用（校验注解实例）
Y_hahaha的博客
05-03 296
注解作为元数据提供约束，大部分注解不会影响代码的执行，但也有一部分注解可用于这一目的 java jdk1.5版本内置了三种标准的注解：（1.5版本开始加入注解） @Override，表示当前的方法定义将覆盖超类中的方法。 @Deprecated，使用了注解为它的元素编译器将发出警告，因为注解@Deprecated是不赞成使用的代码，被弃用的代码。 @SuppressWarnings,关闭...
反射和注解的简单理解
均为学习笔记
03-14 525
1、反射：是Java独有的技术 2、反射是指对于任何一个类，在 “运行的时候” 都可以直接得到这个类的全部成分。 在运行时，可以直接得到这个类的构造器对象。 在运行时，可以直接得到这个类的成员变量对象。 在运行时，可以直接得到这个类的成员方法对象。 反射的核心思想就是得到：编译以后的的class文件对象。 注意：反射是工作在运行时的技术，因为只有运行之后才会有class类对象。 小结：反射的核心思想和关键就是得到：编译以后的class文件对象。 反射是在运行时获取类的字节码文件对象：然后可以
java的注解和反射有什么联系
03-24
Java 的注解和反射有密切联系。注解是在编写代码时添加的特殊标记，可以在运行时由反射方式检测并使用。反射是指程序可以在运行时动态地获取类的信息和调用对象的方法，而注解提供了一种注释和说明方法，可以让代码更容易阅读和理解。因此，Java 中的注解和反射都是为了更好地实现代码的灵活性和可扩展性而存在。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值