java中注解的几大作用
java 数据加解密脱敏 注解
Java数据加解密脱敏注解在数据安全领域发挥着重要作用，它们能够帮助开发人员轻松实现对敏感数据的保护，并且提高了系统的安全性和稳定性。
本文将从以下几个方面对Java数据加解密脱敏注解进行介绍和分析。
1. 加密技术在数据安全中的作用加密技术是保护敏感数据的重要手段之一，它能够将数据转换成一种难以理解的形式，从而防止未经授权的访问和使用。
在Java开发中，常见的加密算法包括对称加密和非对称加密，比如AES、RSA等。
通过使用这些加密算法，可以使敏感数据在存储和传输过程中得到有效的保护，有效降低了数据泄露的风险。
2. 数据脱敏的重要性及应用场景数据脱敏是指对敏感数据进行部分隐藏或替换，以保护数据的隐私性。
在一些场景下，我们需要在测试或演示环境中使用真实数据进行开发和测试，但是又不能直接使用真实的敏感数据。
这时候就需要对数据进行脱敏处理，以保护用户的隐私和数据安全。
常见的数据脱敏技术包括数据的部分隐藏、数据的替换和数据的泛化等。
3. Java中的数据加解密脱敏注解在Java开发中，我们可以通过对敏感数据的注解来实现数据的加解密和脱敏处理。
通过使用注解，可以在程序运行时动态的对数据进行加解密和脱敏处理，而不需要修改原有的代码逻辑。
在Spring框架中，常见的数据加解密脱敏注解包括`Encrypt`、`Decrypt`和`Sensitive`等。
通过在实体类的字段上使用这些注解，可以方便的对数据进行加解密和脱敏处理。
4. 数据加解密脱敏注解的实现原理数据加解密脱敏注解的实现原理一般是通过AOP（面向切面编程）和自定义注解来实现的。
在AOP中，我们可以通过定义切点和通知来动态的对方法进行加解密和脱敏处理，而不需要修改原有的业务逻辑代码。
通过自定义注解，我们可以指定需要加解密和脱敏的字段和对应的处理方式，从而实现对数据的动态处理。
5. 数据加解密脱敏注解的使用方法和注意事项在使用数据加解密脱敏注解时，需要注意一些使用方法和注意事项。
java中override注解原理
文章标题：深度解析Java中Override注解的原理1. 引言在Java编程中，Override注解是一个常见的注解，它用于标识子类方法覆盖父类方法。
在本文中，我们将深入探讨Java中Override注解的原理，包括其作用、实现方式以及使用场景。
通过全面评估和分析，我们将为读者提供对这一注解的深入理解和应用指导。
2. Override注解的作用在Java中，Override注解用于标识子类方法覆盖父类方法。
当我们在子类中重写（覆盖）父类的方法时，为了确保准确性和可读性，可以使用Override注解来显式地声明这一关系。
这样做的好处是可以在编译时检查是否正确地覆盖了父类方法，从而避免出现潜在的错误和bug。
3. Override注解的实现方式在Java中，Override注解是一个元注解，它是被@Target(ElementType.METHOD)修饰的。
这意味着Override注解只能用于修饰方法。
在编译时，Java编译器会检查带有Override注解的方法，如果该方法并没有覆盖父类的方法，就会报编译错误。
这种机制保证了代码的准确性和可靠性。
4. 使用场景Override注解通常用于以下场景：1) 重写父类方法：当我们需要重写父类的方法时，使用Override注解可以帮助我们确保正确地覆盖了父类的方法，提高代码的可读性和可维护性。
2) 接口实现方法：在实现接口的方法时，使用Override注解可以使代码更清晰地表达出这一关系，方便他人阅读和维护代码。
5. 个人观点和理解Override注解作为Java语言中的一个重要注解，可以帮助我们编写更加规范和可靠的代码。
在实际开发中，我认为使用Override注解不仅可以提高代码质量，还可以减少潜在的bug，使代码更易于阅读和维护。
Override注解还能够帮助我们更好地理解类和方法的继承关系，从而更好地设计和组织代码结构。
6. 总结和回顾通过本文的全面解析，我们对Java中Override注解的原理有了更加深刻的理解。
java注解的用法
java注解的用法Java注解是一种用于为Java代码提供元数据的技术。
它可以用来标记类、方法、变量等元素，并为它们提供额外的信息。
注解可以在编译时、运行时甚至是在代码生成时被读取并处理。
Java注解使用‘@’符号作为标识，紧接着是注解的名称。
注解可以包含一些元素，这些元素类似于接口中的方法。
这些元素可以具有默认值，并且可以在使用注解时提供特定的值，也可以使用反射机制来访问注解的元素值。
注解可以用来实现许多功能，包括以下几个方面：1.编译时检查：注解可以用来标记代码中的错误或潜在问题，编译器可以在编译时检查并提供警告或错误信息。
2.自动生成代码：注解可以用于生成代码，例如，使用注解来生成getters和setters方法、序列化代码等。
通过自定义的注解处理器，可以在编译时根据注解生成特定的代码。
3.配置或映射：注解可以用于配置应用程序，例如，通过注解来配置数据库连接、配置文件等。
注解还可以用于实现对象到数据库表的映射。
4.运行时处理：注解可以在运行时使用反射机制来处理，例如，使用注解来进行权限检查、日志记录、跟踪等。
拓展：除了Java内置的注解外，用户还可以自定义注解。
自定义注解需要使用@interface关键字来定义，注解的元素类型可以是基本类型、String、Class、枚举、注解类型、以上类型的数组。
使用自定义注解时，可以按照注解的语法在需要的地方使用注解，并通过反射来读取注解的特定元素值。
可以使用注解处理器来处理自定义注解，在编译时生成相应的代码。
总之，Java注解是一项强大的技术，它可以用于增强代码的可读性、可维护性和功能性。
通过合理使用注解，可以减少重复代码、提高代码的可靠性和效率。
java之注解
java之注解注解(Annotation)：相当于⼀种标记,标记可以加加在包,类,属性,⽅法,⽅法参数,局部变量上没有外部解析⼯具等对注解加以解析和处理的，则不会对代码的产⽣任何的影响。
⼀般使⽤反射读取注解信息-----------------------------------------------------------------------------------内置注解:@Override：限定重写⽗类⽅法, 该注释只能⽤于⽅法@Deprecated：⽤于表⽰某个程序元素(类, ⽅法等)已过时，不建议使⽤@SuppressWarnings：抑制编译器警告-------------------------------------------------------------元注解：描述注解的注解,只能使⽤注解上的注解@Target：说明注解可以出现在哪些地⽅不添加此注解表⽰该注解类可以在任何地⽅使⽤⼀般使⽤枚举类ElementType的枚举常量TYPE代表类 FIELD代表属性 METHOD代表⽅法@Retention：注解的⽣命周期，三种取值RetentionPolicy.SOURCERetentionPolicy.CLASSRetentionPolicy.RUNTIME 反射调⽤使⽤这个值@Inherited:指⽰注释类型被⾃动继承。
注解继承：⽅法上的注解是否被继承只是否重写有关，如果重写了⽗类的⽅法，则⽗类⽅法上的注解就不会被继承过来。
类上的注解是否能够被继承，与注解是否被@Inherited有关--------------------------------------------------------------⾃定义注解：1)定义注解类：public @interface 类名默认继承Annotation类2）每个⽅法声明定义为⼀个元素（成员变量）⽅法的返回值类型就是元素类型，⽅法不能有参数⽅法的返回值类型：基本数据类型，String，Class，枚举，注解及它们的数组每个⾃定义注解类都有这个⽅法: annotationType() 返回此注解对象的类型返回值是class对象⽅法可以给默认值例: String value() default "HELLO" ;--------------------------------------------------------------Class类 Field类 Method类使⽤注解常⽤⽅法:Class类独有的: isAnnotation() 如果此class对象表⽰⼀个注解类型，则返回 true；否则返回 falseisAnnotationPresent(Class<? extends Annotation> annotationClass) 如果指定类型的注解存在于此元素上，则返回 true，否则返回 false。
java注解用法
java注解用法Java注解是一种元数据标记语言，它提供了一种方法，用于在代码中添加附加信息和元数据。
注解通常用于提供程序代码中所需的特定信息，如类、方法、变量和参数等。
Java注解可以用于说明代码的行为、配置代码的行为、标记代码以供后续处理、生成代码、生成文档等。
Java中的注解由“@”符号紧跟注解名称组成，可以有多个注解修饰一个元素。
Java注解可以设置默认值，以及支持基本数据类型、字符串、枚举类型和注解类型作为注解的成员。
Java注解的使用方式有三种：1. 类级别注解：用于修饰类，如@Entity、@Service等。
这些注解通常用于配置和标识类的作用。
2. 方法级别注解：用于修饰方法，可以用于配置方法的行为、生成文档等。
例如，@Override、@RequestMapping等。
3. 字段级别注解：用于修饰字段，可以用于标识字段、生成文档等。
例如，@Autowired、@NotNull等。
Java注解的使用方式大致可以分为三个步骤：1. 定义注解：使用@interface关键字定义一个注解，并在注解中定义各个成员。
2. 注解修饰元素：通过在元素前添加注解来修饰该元素，并设置注解的值。
3. 解析注解：使用反射机制解析注解，获取注解的值，并根据注解的值进行相应的处理。
Java注解的应用场景很广泛，可以用于代码的配置、文档生成、代码生成等。
1. 配置：注解可以用于配置代码的行为。
例如，通过注解来配置数据库连接信息、配置日志级别、配置线程池等。
2. 文档生成：注解可以用于生成API文档。
例如，通过注解来说明方法的用途、参数的含义、返回值的含义等，然后通过代码解析注解生成文档。
3. 代码生成：注解可以用于生成一些重复性的代码。
例如，通过注解对某个接口进行标记，然后通过代码解析注解，生成接口的实现类。
4. 标记：注解可以用于标记代码。
例如，通过注解对某个方法进行标记，然后在某个地方对标记的方法进行特殊处理。
java中注解的原理
java中注解的原理
Java中注解是一种元数据，它可以提供关于程序代码的额外信息。
注解可以应用于类、方法、变量、参数等元素之上，提供关于这些元素的额外信息。
注解是由一组元素值组成的键值对，在Java中被表示为注解接口的实现类。
Java编译器在编译时可以解析注解，并在编译后的字节码中保留这些注解。
这些注解可以在程序运行时通过反射机制被访问。
注解的应用可以提高程序的可读性、可维护性和可重用性。
注解的定义是通过注解接口来实现的。
注解接口定义了一组元素值，这些元素值可以被用来填充注解的值。
元素值可以是基本类型、String类型、Class类型、枚举类型或注解类型。
注解的元素值可以使用默认值，如果没有指定实际值，则使用默认值。
注解的应用是通过在代码中使用注解接口的实现类来实现的。
注解可以应用于类、方法、变量、参数等元素之上。
注解的使用方式为@注解名称(元素名称=元素值)，其中注解名称为注解接口的名称，元素名称为注解接口中定义的元素名称，元素值为注解的实际值。
Java中的许多库和框架都使用注解来提供额外的信息和功能。
例如，Spring框架使用注解来定义依赖注入和面向切面编程等功能。
JUnit测试框架使用注解来定义测试用例和测试套件。
总之，Java中注解是一种非常有用的元数据，它可以提供关于程序代码的额外信息，提高程序的可读性、可维护性和可重用性。
注解的原理是通过注解接口的实现类来定义和应用注解。
java中注解的几大作用
注解的作用：1、生成文档。
这是最常见的，也是java 最早提供的注解。
常用的有@see @param @return 等2、跟踪代码依赖性，实现替代配置文件功能。
比较常见的是spring 2.5 开始的基于注解配置。
作用就是减少配置。
现在的框架基本都使用了这种配置来减少配置文件的数量。
以后java的程序开发，最多的也将实现注解配置，具有很大用处;3、在编译时进行格式检查。
如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。
使用方法详解：下面是注解类,其实注解也就是一个类文件package annotation;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;import entity.PersonChiness;/**** Retention:保持、保留* RetentionPolicy：政策、方针* @author huawei*@Retention*1、指示注释类型的注释要保留多久。
如果注释类型声明中不存在Retention 注释，则保留策略默认为RetentionPolicy.CLASS*2、有三种取值(代表三个阶段)：* RetentionPolicy.SOURCE:保留注解到java源文件阶段，例如Override、SuppressWarnings * RetentionPolicy.CLASS:保留注解到class文件阶段,例如* RetentionPolicy.RUNTIME:保留注解到运行时阶段即内存中的字节码,例如Deprecated*///元注解：表示的是注解的注解，（同义词有元信息、元数据）//如果不加,javac会把这无用的注解丢掉@Retention(RetentionPolicy.RUNTIME)@Target({ElementType.TYPE,ElementType.METHOD})//指定该注解使用的用处：用在class上和用在方法体上。
java注解通俗易懂说明
java注解通俗易懂说明Java 注解（Annotation）是一种代码标记机制，用于为代码添加元数据。
这些元数据可以被编译器用来生成代码、检查代码的正确性，或者在运行时被 Java 虚拟机（JVM）用来执行某些操作。
下面是一些关于 Java 注解的通俗易懂说明：1. 用途：注解主要用于为代码提供额外的信息，这些信息可以用于多种目的。
例如，你可以使用注解来标记某个方法可能抛出的异常，或者标记某个类是一个测试类。
2. 定义：注解使用`` 符号定义，后面跟着注解的名称和可选的参数。
例如，`Override` 是一个常用的注解，它告诉编译器这个方法是重写了父类的方法。
3. 使用：你可以在类、方法、变量等上面使用注解。
例如，你可以在一个方法上使用 `Deprecated` 注解来标记这个方法已经过时。
4. 运行时处理：有些注解可以在运行时被处理。
例如，`Autowired` 是一个Spring 框架的注解，它可以在运行时自动注入依赖。
5. 自定义注解：你可以定义自己的注解，并为它们添加属性。
例如，你可以定义一个 `MyAnnotation` 注解，并为它添加一个 `value` 属性。
6. 处理工具：有许多工具可以处理注解，例如编译器插件、IDE 插件等。
这些工具可以根据注解的信息执行特定的操作。
7. 与元数据的关系：注解可以视为一种元数据，因为它们为代码添加了额外的信息。
这些元数据可以被读取并用于多种目的，例如生成文档、生成测试代码、进行代码分析等。
8. 与注释的区别：虽然注解和注释都为代码提供了额外的信息，但它们的使用方式和目的不同。
注释是用于为代码提供说明或文档，不会被编译器或JVM 读取。
而注解是用于为代码提供元数据，可以被编译器或 JVM 读取和处理。
希望这些说明能帮助你更好地理解 Java 注解的概念和用途。
如果你有任何其他问题，欢迎继续提问。
java《注解解析》
Java注解(Annotation)(1) Annotation(注释)是JDK5.0及以后版本引入的。
它可以用于创立文档，跟踪代码中的依赖性，甚至执行根本编译时检查。
注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。
它们都不会直接影响到程序的语义，只是作为注释〔标识〕存在，我们可以通过反射机制编程实现对这些元数据的访问。
另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。
元数据的作用如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类：编写文档：通过代码里标识的元数据生成文档。
代码分析：通过代码里标识的元数据对代码进行分析。
编译检查：通过代码里标识的元数据让编译器能实现根本的编译检查。
根本内置注释@OverrideJava代码1. package com.iwtxokhtd.annotation;2. /**3. * 测试Override注解4. * @author Administrator5. *6. */7. public class OverrideDemoTest {8.9. //@Override10. public String tostring(){11. return "测试注释";12. }13. }package com.iwtxokhtd.annotation;/*** 测试Override注解* @author Administrator*public class OverrideDemoTest {//@Overridepublic String tostring(){return "测试注释";}}@Deprecated的作用是对不应该在使用的方法添加注释，当编程人员使用这些方法时，将会在编译时显示提示信息，它与javadoc里的@deprecated标记有相同的功能，准确的说，它还不如javadoc @deprecated，因为它不支持参数，使用@Deprecated的例如代码例如如下：Java代码1. package com.iwtxokhtd.annotation;2. /**3. * 测试Deprecated注解4. * @author Administrator5. *6. */7. public class DeprecatedDemoTest {8. public static void main(String[] args) {9. //使用DeprecatedClass里声明被过时的方法10. DeprecatedClass.DeprecatedMethod();11. }12. }13. class DeprecatedClass{14. @Deprecated15. public static void DeprecatedMethod() {16. }17. }package com.iwtxokhtd.annotation;/*** 测试Deprecated注解* @author Administrator*/public class DeprecatedDemoTest {public static void main(String[] args) {//使用DeprecatedClass里声明被过时的方法DeprecatedClass.DeprecatedMethod();}}class DeprecatedClass{@Deprecatedpublic static void DeprecatedMethod() {}}@SuppressWarnings,其参数有：deprecation，使用了过时的类或方法时的警告unchecked，执行了未检查的转换时的警告fallthrough，当Switch 程序块直接通往下一种情况而没有Break 时的警告path，在类路径、源文件路径等中有不存在的路径时的警告serial，当在可序列化的类上缺少serialVersionUID 定义时的警告finally ，任何finally 子句不能正常完成时的警告all，关于以上所有情况的警告Java代码1. package com.iwtxokhtd.annotation;2.3. import java.util.ArrayList;4. import java.util.List;5.6. public class SuppressWarningsDemoTest {7.8. public static List list=new ArrayList();9. @SuppressWarnings("unchecked")10. public void add(String data){11. list.add(data);12. }13. }package com.iwtxokhtd.annotation;import java.util.ArrayList;import java.util.List;public class SuppressWarningsDemoTest {public static List list=new ArrayList();@SuppressWarnings("unchecked")public void add(String data){list.add(data);}}(2)自定义注释它类似于新创立一个接口类文件，但为了区分，我们需要将它声明为@interface,如下例：Java代码1. public @interface NewAnnotation {2. }public @interface NewAnnotation {}使用自定义的注释类型Java代码1. public class AnnotationTest {2. @NewAnnotation3. public static void main(String[] args) {4. }5. }public class AnnotationTest {@NewAnnotationpublic static void main(String[] args) {}}为自定义注释添加变量Java代码1. public @interface NewAnnotation {2. String value();3. }public @interface NewAnnotation {String value();}Java代码1. public class AnnotationTest {2. @NewAnnotation("main method")3. public static void main(String[] args) {4. saying();5. }6. @NewAnnotation(value = "say method")7. public static void saying() {8. }9. }public class AnnotationTest {@NewAnnotation("main method")public static void main(String[] args) {saying();}@NewAnnotation(value = "say method")public static void saying() {}}定义一个枚举类型，然后将参数设置为该枚举类型，并赋予默认值Java代码1. public @interface Greeting {2. public enum FontColor{3. BLUE,RED,GREEN4. };5. String name();6. FontColor fontColor() default FontColor.RED;}7. }public @interface Greeting {public enum FontColor{BLUE,RED,GREEN};String name();FontColor fontColor() default FontColor.RED;}}这里有两种选择，其实变数也就是在赋予默认值的参数上，我们可以选择使用该默认值，也可以重新设置一个值来替换默认值Java代码1. @NewAnnonation("main method")2. public static void main(String[] args) {3. saying();4. sayHelloWithDefaultFontColor();5. sayHelloWithRedFontColor();6.7. }8. @NewAnnonation("say method")9. public static void saying(){10.11. }12. //此时的fontColor为默认的RED13. @Greeting(name="defaultfontcolor")14. public static void sayHelloWithDefaultFontColor() {15.16. }17. //现在将fontColor改为BLUE18. @Greeting(name="notdefault",fontColor=Greeting.FontColor.BLUE)19. public static void sayHelloWithRedFontColor() {20.21. }@NewAnnonation("main method")public static void main(String[] args) {saying();sayHelloWithDefaultFontColor();sayHelloWithRedFontColor();}@NewAnnonation("say method")public static void saying(){}//此时的fontColor为默认的RED@Greeting(name="defaultfontcolor")public static void sayHelloWithDefaultFontColor() {}//现在将fontColor改为BLUE@Greeting(name="notdefault",fontColor=Greeting.FontColor.BLUE)public static void sayHelloWithRedFontColor() {}(3)注释的高级应用限制注释的使用范围用@Target指定ElementType属性Java代码1. package ng.annotation;2. public enum ElementType {3. TYPE,4. // 用于类，接口，枚举但不能是注释5. FIELD,6. // 字段上，包括枚举值7. METHOD,8. // 方法，不包括构造方法9. PARAMETER,10. // 方法的参数11. CONSTRUCTOR,12. //构造方法13. LOCAL_V ARIABLE,14. // 本地变量或catch语句15. ANNOTATION_TYPE,16. // 注释类型(无数据)17. PACKAGE18. // Java包19. }package ng.annotation;public enum ElementType {TYPE,// 用于类，接口，枚举但不能是注释FIELD,// 字段上，包括枚举值METHOD,// 方法，不包括构造方法PARAMETER,// 方法的参数CONSTRUCTOR,//构造方法LOCAL_VARIABLE,// 本地变量或catch语句ANNOTA TION_TYPE,// 注释类型(无数据)PACKAGE// Java包}注解保持性策略Java代码1. //限制注解使用范围2. @Target({ElementType.METHOD,ElementType.CONSTRUCTOR})3. public @interface Greeting {4.5. //使用枚举类型6. public enum FontColor{7. BLUE,RED,GREEN8. };9. String name();10. FontColor fontColor() default FontColor.RED;11. }//限制注解使用范围@Target({ElementType.METHOD,ElementType.CONSTRUCTOR}) public @interface Greeting {//使用枚举类型public enum FontColor{BLUE,RED,GREEN};String name();FontColor fontColor() default FontColor.RED;}在Java编译器编译时，它会识别在源代码里添加的注释是否还会保存，这就是RetentionPolicy。
自定义注解 封装注解 继承注解
自定义注解封装注解继承注解自定义注解、封装注解和继承注解是Java编程中非常重要的概念。
它们可以帮助我们更好地组织和管理代码，提高代码的可读性和可维护性。
在本文中，我们将从简单到复杂的角度来探讨这些概念，以便读者能够更深入地理解它们的作用和用法。
1. 自定义注解自定义注解是Java语言中一种非常强大的特性。
通过自定义注解，我们可以为我们的代码添加元数据信息，从而使代码更加灵活和扩展。
在Java中，自定义注解使用@interface关键字来定义。
我们可以在注解中定义属性，这些属性可以在使用注解的地方进行配置。
例如：```javapublic @interface MyAnnotation {String value();}```在上面的例子中，我们定义了一个名为MyAnnotation的注解，并且添加了一个名为value的属性。
我们可以在使用该注解的地方对value属性进行配置，如下所示：```java@MyAnnotation(value = "Hello")public class MyClass {// ...}```通过自定义注解，我们可以为我们的代码添加更多的元数据信息，从而提高代码的可读性和可维护性。
2. 封装注解封装注解是指在一个注解中包含另一个注解。
通过封装注解，我们可以更好地组织和管理注解，使其更具有可扩展性和灵活性。
例如：```javapublic @interface MyMetaAnnotation {MyAnnotation value();}```在上面的例子中，我们定义了一个名为MyMetaAnnotation的注解，并且包含了一个名为value的属性，其类型为MyAnnotation。
这样一来，我们可以在使用MyMetaAnnotation的地方，同时配置MyAnnotation的属性。
这种封装使得我们可以更好地重用和组织注解，使其更加灵活和可扩展。
java《注解解析》
Java注解(Annotation)(1) Annotation(注释)是及以后版本引入的。
它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。
注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。
它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。
另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。
元数据的作用如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类：编写文档：通过代码里标识的元数据生成文档。
代码分析：通过代码里标识的元数据对代码进行分析。
编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。
基本内置注释@OverrideJava代码1. package2. /**3. * 测试Override注解4. * @author Administrator5. *6. */7. public class OverrideDemoTest {8.9. public String tostring(){11. return "测试注释";12. }13. }package/*** 测试Override注解* @author Administrator**/public class OverrideDemoTest {package2. /**3. * 测试Deprecated注解4. * @author Administrator5. *6. */7. public class DeprecatedDemoTest {8. public static void main(String[] args) {9. ();11. }12. }13. class DeprecatedClass{14. @Deprecated15. public static void DeprecatedMethod() {16. }17. }package/*** 测试Deprecated注解* @author Administrator**/public class DeprecatedDemoTest {public static void main(String[] args) {package2.3. import4. import5.6. public class SuppressWarningsDemoTest {7.8. public static List list=new ArrayList();9. @SuppressWarnings("unchecked")10. public void add(String data){11. (data);12. }13. }packageimportimportpublic class SuppressWarningsDemoTest {public static List list=new ArrayList();@SuppressWarnings("unchecked")public void add(String data){(data);}}(2)自定义注释它类似于新创建一个接口类文件，但为了区分，我们需要将它声明为@interface,如下例：Java代码1. public @interface NewAnnotation {2. }public @interface NewAnnotation {}使用自定义的注释类型Java代码1. public class AnnotationTest {2. @NewAnnotation3. public static void main(String[] args) {4. }5. }public class AnnotationTest {@NewAnnotationpublic static void main(String[] args) {}}为自定义注释添加变量Java代码1. public @interface NewAnnotation {2. String value();3. }public @interface NewAnnotation { String value();}Java代码1. public class AnnotationTest {2. @NewAnnotation("main method")3. public static void main(String[] args) {4. saying();5. }6. @NewAnnotation(value = "say method")7. public static void saying() {8. }9. }public class AnnotationTest {@NewAnnotation("main method")public static void main(String[] args) {saying();}@NewAnnotation(value = "say method")public static void saying() {}}定义一个枚举类型，然后将参数设置为该枚举类型，并赋予默认值Java代码1. public @interface Greeting {2. public enum FontColor{3. BLUE,RED,GREEN4. };5. String name();6. FontColor fontColor() default ;}7. }public @interface Greeting {public enum FontColor{BLUE,RED,GREEN};String name();FontColor fontColor() default ;}}这里有两种选择，其实变数也就是在赋予默认值的参数上，我们可以选择使用该默认值，也可以重新设置一个值来替换默认值Java代码1. @NewAnnonation("main method")2. public static void main(String[] args) {3. saying();4. sayHelloWithDefaultFontColor();5. sayHelloWithRedFontColor();6.7. }8. @NewAnnonation("say method")9. public static void saying(){10.11. }12. @Greeting(name="defaultfontcolor")14. public static void sayHelloWithDefaultFontColor() {15.16. }17. @Greeting(name="notdefault",fontColor=19. public static void sayHelloWithRedFontColor() {20.21. }@NewAnnonation("main method")public static void main(String[] args) {saying(); sayHelloWithDefaultFontColor(); sayHelloWithRedFontColor();}@NewAnnonation("say method") public static void saying(){}package2. public enum ElementType {3. TYPE,4. FIELD,6. METHOD,8. PARAMETER,10. CONSTRUCTOR,12. LOCAL_VARIABLE,14. ANNOTATION_TYPE,16. PACKAGE18. }packagepublic enum ElementType { TYPE,@Target({,})3. public @interface Greeting {5. public enum FontColor{7. BLUE,RED,GREEN8. };9. String name();10. FontColor fontColor() default ;11. }package2. public enum RetentionPolicy {3. SOURCE,4. CLASS,6. RUNTIME8. }packagepublic enum RetentionPolicy { SOURCE,@Retention3. public @interface Greeting {4.5. public enum FontColor{7. BLUE,RED,GREEN8. };9. String name();10. FontColor fontColor() default ;@Documented4. public @interface Greeting {5.6. public enum FontColor{8. BLUE,RED,GREEN9. };10. String name();11. FontColor fontColor() default ;12. }@Inherited3. public @interface Greeting {4.5. public enum FontColor{7. BLUE,RED,GREEN8. };9. String name();10. FontColor fontColor() default ;11. }package2. import3. import4.5. public class ReadAnnotationInfoTest {7. public static void main(String[] args)throws Exception {8. Class c=("");10. Method []methods=();12. Annotation[] annotations;14. for(Method method:methods){16. annotations=();18. for(Annotation an:annotations){20. "方法名为："+()+" 其上面的注解为："+().getSimpleName());21. Method []meths=().getDeclaredMethods();22. for(Method meth:meths){24. "注解的变量名为："+());25. }26.27. }28. }29.30. }31.32. }packageimportimportetSimpleName());Method []meths=().getDeclaredMethods();ppend("sqlMap", sqlMap) .append("type", type).toString();}}类实现：import@SuppressWarnings("unchecked")public class MyService {@DataSource(type="B", sqlMap="com/annotation/")private SqlMapClient sqlMapB = null;@DataSource(type="A", sqlMap="com/annotation/")private SqlMapClient sqlMapA = null;qua ls(fieldName)) {return null;}Class<> clazz = ();try{String methodname = "get" + (fieldName);Method method = (methodname);(true);return(obj);} catch(Exception e) {try{Field field = (fieldName);(true);return(obj);} catch(Exception e1) {();}}return null;}public static void setFieldValue(Object target, String fname, Clas s<> fieldClass,Object fieldObj) {if(!())) {return;}Class<> clazz = ();try{Method method = ("set" + (0))+ (1), fieldClass);(true);(target, fieldObj);} catch(Exception e) {try{Field field = (fname);(true);(target, fieldObj);} catch(Exception e1) {();}}}}已经基本大功告成了，只要将我们的类使用起来即可。
JAVA注解的几大作用及使用方法详解
JAVA注解的几大作用及使用方法详解
一、什么是注解
1、注解（Annotation），也叫元数据，是源代码的补充说明，是JDK1.5之后新增的一个特性。
注解可以理解成一种代码级别的标记，它可以提供关于代码一些额外的说明，注解在运行时可以被解析，通过反射实现。
下面介绍注解的几大作用和使用方法：
二、注解的几大作用
1、标记注解：注解用于提供关于代码的额外文档说明，比如提供类的作用，方法的用法，类的继承关系等；
3、编码实现：程序员可以实现低耦合，比如在生成XML文件时，可以使用注解生成XML节点，而无需调用XML读写类；
5、自定义注解：可以使用自定义注解，来标识函数或类，这样运行时可以根据注解采取特定的行为；
三、使用注解的步骤
1、定义注解：注解由一个或多个注解元素构成，每个注解元素代表注解提供的一个属性。
java注解详解
JA V A 注解的几大作用及使用方法详解注解（Annotation）1、Annotation的工作原理：JDK5.0中提供了注解的功能，允许开发者定义和使用自己的注解类型。
该功能由一个定义注解类型的语法和描述一个注解声明的语法，读取注解的API，一个使用注解修饰的class 文件和一个注解处理工具组成。
Annotation并不直接影响代码的语义，但是他可以被看做是程序的工具或者类库。
它会反过来对正在运行的程序语义有所影响。
Annotation可以从源文件、class文件或者在运行时通过反射机制多种方式被读取。
常见的作用有以下几种:1,生成文档。
这是最常见的，也是java 最早提供的注解。
常用的有@see @param @return 等2,跟踪代码依赖性，实现替代配置文件功能。
比较常见的是spring 2.5 开始的基于注解配置。
作用就是减少配置。
现在的框架基本都使用了这种配置来减少配置文件的数量。
3,在编译时进行格式检查。
如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。
*@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。
*方法的名称就是参数的名称，返回值类型就是参数的类型。
*可以通过default来声明参数的默认值。
父类,接口ng.annotation包ng.annotation 中包含所有已定义或自定义注解所需用到的原注解和接口。
如接口ng.annotation.Annotation 是所有注解继承的接口,并且是自动继承，不需要定义时指定，类似于所有类都自动继承Object。
该包同时定义了四个元注解;常见注解@Override注解：注释类型Override@Target(value=METHOD)@Retention(value=SOURCE)public @interface Override@Override注解表示子类要重写父类的对应方法。
java注解应用场景
java注解应用场景
Java注解的应用场景如下：
1. 代码配置：注解可以用于配置代码，通过在注解中指定参数来控制代码的行为。
例如，Spring框架中的@Configuration注解可以用于配置类，告诉Spring 框架该类是一个配置类，并且可以通过在注解中指定参数配置一些行为。
2. 编译时处理：注解可以在编译时对代码进行一些处理，例如使用注解生成代码。
例如，JPA规范中的@Entity注解可以用于标识一个类是一个实体类，编译器可以根据这个注解生成相应的数据库表结构。
3. 运行时处理：注解可以在运行时对代码进行一些处理。
例如，JUnit框架中的@Test注解可以用于标识一个方法是一个测试方法，JUnit运行器在运行测试时会找到使用了@Test注解的方法，并执行它们。
4. 生成文档：注解可以用于生成文档，通过在注解中指定一些元数据来描述代码的行为和使用方法。
例如，Java标准库中的@Deprecated注解可以用于标识一个方法或类已过时，并在生成的文档中显示出来。
5. 静态检查：注解可以在编译期间对代码进行静态检查，提供一些编译期间的检查功能。
例如，使用@NonNull注解可以告诉编译器该参数不能为空，编译器在编译期间会进行检查，如果发现该参数为空，则会产生编译错误。
6. 应用框架：注解可以用于应用框架中，用于辅助框架进行一些操作。
例如，Spring框架中的@Autowired注解可以用于自动装配依赖，框架在实例化Bean 时会自动查找使用了@Autowired注解的字段或方法，然后自动注入相应的依赖。
java语言三种注释的语法格式以及用途
java语言三种注释的语法格式以及用途
Java语言中有三种注释方式，它们分别是：
1. 单行注释：
语法格式：使用两个斜杠（//）开始注释，后面跟随注释内容。
示例：
```java
// 这是一个单行注释
int x = 10; // 将 x 的值设为 10
```
用途：用于在一行中对代码进行简要说明，帮助开发者理解代码的功能和意图。
2. 多行注释：
语法格式：使用 / 开始注释，使用 / 结束注释。
示例：
```java
/
这是一个多行注释，可以跨越多行。
在这里说明代码的功能和作用。
/
int y = 20; / 将 y 的值设为 20 /
```
用途：用于对代码块进行详细说明，可以跨越多行。
通常用于解释复杂的代码逻辑或提供额外的信息。
3. Javadoc 注释：
语法格式：使用 / 开始注释，使用 / 结束注释。
这种注释方式也被称为Javadoc 注释。
示例：
```java
/
这是一个 Javadoc 注释，用于描述类的功能和属性。
在这里编写对类的描述信息。
/
public class MyClass { / ... / }
```
用途：用于生成 Javadoc 文档。
通过 Javadoc 工具，可以将注释解析为HTML 格式的文档，提供给开发人员参考和查阅。
java注解详解及使用场景
java注解详解及使用场景Java注解是一种元数据（metadata）机制，它提供了一种将元数据信息与代码进行关联的方式。
注解可以在源代码中以特殊的标记方式添加，用于提供额外的信息，例如配置、说明、约束等。
在编译时、运行时或者通过反射机制，可以读取并处理这些注解。
Java注解的使用场景非常广泛，下面我将从多个角度详细介绍。
1. 文档生成，注解可以用于生成文档。
通过在代码中添加注解，可以提取其中的信息，生成API文档或者其他形式的文档。
2. 编译时检查，注解可以用于编译时的静态检查。
例如，使用注解标记方法的重写、接口的实现等，编译器可以检查是否符合语法规范。
3. 配置文件，注解可以用于配置文件的解析。
通过解析注解，可以自动加载配置文件，并将配置信息注入到相应的对象中。
4. 单元测试，注解可以用于单元测试框架，标记测试用例、测试组等。
5. 框架扩展，注解可以用于框架的扩展。
例如，Spring框架中的注解可以用于标记Bean、依赖注入等。
6. AOP编程，注解可以用于实现面向切面编程（AOP）。
通过在代码中添加注解，可以定义切点，并在相应的切点上执行特定的逻辑。
7. 数据库映射，注解可以用于数据库映射。
通过注解，可以将Java对象与数据库表进行映射，简化数据库操作。
8. 安全检查，注解可以用于安全检查。
例如，使用注解标记敏感操作，通过注解检查用户的权限，确保操作的安全性。
9. 日志记录，注解可以用于日志记录。
通过注解，可以自动记录方法的执行时间、参数等信息。
10. 代码生成，注解可以用于代码生成。
通过解析注解，可以生成相应的代码，减少重复劳动。
总结来说，Java注解是一种非常强大的机制，可以用于各种各样的场景。
它提供了一种灵活、简洁的方式来为代码添加额外的信息，使得代码更加清晰、易于维护。
无论是在文档生成、编译时检查、配置文件解析，还是在单元测试、框架扩展、AOP编程等方面，注解都发挥着重要的作用。
通过合理地使用注解，可以提高代码的可读性、可维护性和可扩展性。
java编程基础：注解的功能和作用，自定义注解
java编程基础：注解的功能和作⽤，⾃定义注解1，什么是注解：从JDK5开始，Java增加了对元数据 (MetaData)的⽀持，也就是Annotation注解，这种注解与注释不⼀样，注解其实是代码⾥的特殊标记，这些标记可以在编译、类加载运⾏时被读取并执⾏相应的处理。
通过使⽤注解，程序开发⼈员可以在不改变原有逻辑的情况下，在源⽂件中嵌⼊⼀些补充的信息。
代码分析⼯具、开发⼯具和部署⼯具可以通过这些补充信息进⾏验证或者进⾏部署。
注解提供了⼀种为程序元素设置元数据的⽅法，从某些⽅⾯来看，注解就像修饰符，可⽤于修饰包、类、构造器、⽅法、成员变量、参数、局部变量的声明，这些信息被存储在注解 "name=value"对中。
注解能被⽤来为程序元素(类、⽅法、成员变量等)设置元数据。
值得指出的是，注解不影响程序代码的执⾏，⽆论增加、删除注解，代码都始终如⼀地执，如果希望让程序中的注解在运⾏时起⼀定的作⽤，只有通过某种配套的⼯具对注解中的信息进⾏访问和处理，访问和处理注解的⼯具统称APT，也就是Annotation Processing Tool的缩写。
2，Java5的常⽤的基本注解：(1),重写⽗类⽅法注解@Override：该注解作⽤在⼀个⽅法上，告诉编译器检查该该⽅法是不是⼀个重写⽗类的⽅法。
这个注解的作⽤主要是为了帮助程序员屏蔽⼀些低级错误，⽐如，我们有⼀个⽅法叫做info，有的程序员可能就直接写成了inf或者inf0,到时候排查的时候，也不太⽅便，如果在编译的时候就能把这个错误报出来就是最好的。
⼦类重写⽗类⽅法，请必须加@Override注解(2)，标记过时@Deprecated：该注解也是作⽤在⼀个类或者⽅法上，表⽰⼀个类或者⽅法是不是已过时的，如果在其他程序⾥使⽤了已过时的类或者⽅法，编译器会给出警告。
java9开始为Deprecated提供了两个新的属性：forRemoval: boolean 类型的属性指定该API在将来是否会被删除since: String 类型的属性指定该API从哪个版本被标记为过时(3)，取消告警@SuppressWanings：@SuppressWanings指⽰被该注解修饰的程序元素(以及该程序元素中的所有⼦元素)取消显⽰指定的编译器警告，@SuppressWanings⼀直作⽤于该程序元的所有⼦元素。
injectable注解
injectable注解在Java开发过程中，为了实现代码的可重用性和可读性，使用注解已经成为了必要的工具之一。
Injectable注解就是其中一种。
Injectable注解是Guice框架中的一个注解，其作用主要是标注哪些类或方法需要被注入。
在使用该注解时，需要在config中指定相应的Injector，然后将需要注入的类或方法标注上Injectable注解。
使用Injectable注解可以有效地减少代码的耦合度，增加代码的灵活性，同时也可以使代码更加易读易懂。
下面，我们将从以下几个方面详细介绍Injectable注解。
1. Injectable注解的作用Injectable注解的作用非常明显，就是标注需要被注入的类或方法。
在Guice框架中，我们需要通过Injectable注解来告诉Injector 哪些类或方法需要被注入。
这样，Injector在初始化应用程序时就可以将这些类或方法实例化，并注入到需要它们的地方。
2.使用Injectable注解的场景在实际的应用开发中，如果不使用依赖注入（DI）框架，很容易出现如下场景：如果需要更改某个类的实现，我们就需要在代码中大量修改该类的引用。
这样做的结果就是代码的可读性和可维护性会大幅降低。
当我们需要将某个类的实例传递给另一个类时，我们就需要将该实例作为参数传入。
这样做会导致代码变得冗长而难以维护，同时也很容易出错。
使用Injectable注解可以避免以上的问题。
通过其标记需要注入的类或方法，我们可以让框架自动进行依赖注入，从而减少代码的耦合度，提高代码的灵活性和可维护性。
3. Injectable注解的使用方法在使用Injectable注解时，需要了解以下两个方面：在Java类中使用Injectable注解在Java类中使用Injectable注解需要采用如下方式：```@Injectablepublic class MyClass {// ...}```在上述代码中，我们使用@Injectable注解标注了MyClass类。
JAVA注解的几大作用及使用方法详解
JAVA注解的⼏⼤作⽤及使⽤⽅法详解java 注解，从名字上看是注释，解释。
但功能却不仅仅是注释那么简单。
注解（Annotation）为我们在代码中添加信息提供了⼀种形式化的⽅法，是我们可以在稍后某个时刻⽅便地使⽤这些数据（通过解析注解来使⽤这些数据），常见的作⽤有以下⼏种：1.⽣成⽂档。
这是最常见的，也是java 最早提供的注解。
常⽤的有@see @param @return 等；2.跟踪代码依赖性，实现替代配置⽂件功能。
⽐较常见的是spring 2.5 开始的基于注解配置。
作⽤就是减少配置。
现在的框架基本都使⽤了这种配置来减少配置⽂件的数量；3.在编译时进⾏格式检查。
如@Override放在⽅法前，如果你这个⽅法并不是覆盖了超类⽅法，则编译时就能检查出；包 ng.annotation 中包含所有定义⾃定义注解所需⽤到的原注解和接⼝。
如接⼝ ng.annotation.Annotation 是所有注解继承的接⼝,并且是⾃动继承，不需要定义时指定，类似于所有类都⾃动继承Object。
该包同时定义了四个元注解，Documented,Inherited,Target(作⽤范围，⽅法，属性，构造⽅法等),Retention(⽣命范围，源代码，class,runtime)。
下⾯将在实例中逐个讲解他们的作⽤，及使⽤⽅法。
Inherited : 在您定义注解后并使⽤于程序代码上时，预设上⽗类别中的注解并不会被继承⾄⼦类别中，您可以在定义注解时加上ng.annotation.Inherited 限定的Annotation，这让您定义的Annotation型别被继承下来。
注意注解继承只针对class 级别注解有效（这段建议看完全⽂后在来回顾）。
多说⽆益，下⾯就⼀步步从零开始建⼀个我们⾃⼰的注解。
建⽴第⼀个注解package com.tmser.annotation;public @interface TestA {//这⾥定义了⼀个空的注解，它能⼲什么呢。
java注解的定义
Java注解的定义什么是Java注解？Java注解是一种用于在源代码中添加元数据（metadata）的方式。
它们可以用来提供给编译器、工具和运行时环境额外的信息，以便于进行静态分析、编译时处理或运行时处理。
注解是从Java 5开始引入的，它们为开发人员提供了一种声明性的方式来描述代码的特性和行为。
通过使用注解，可以将额外的信息与类、方法、字段等元素相关联，以实现更高级别的编程。
注解的语法Java注解使用@符号作为前缀，后跟注解名称和可选参数列表。
例如：@AnnotationName有些注解包含参数，参数可以在括号中指定。
例如：@AnnotationName(parameter1 = value1, parameter2 = value2)内置注解Java为开发人员提供了一些内置的注解。
以下是其中几个常用的内置注解：•@Override: 表示方法重写父类或接口定义的方法。
•@Deprecated: 表示被标记的元素已过时，并且不鼓励使用。
•@SuppressWarnings: 抑制指定类型的警告。
这些内置注解可以帮助开发人员更好地理解代码，并提供编译器级别的错误检查和警告。
自定义注解除了使用内置注解，Java还允许开发人员创建自定义注解。
自定义注解可以根据具体需求来定义，可以包含元素、默认值和约束条件。
定义注解要定义一个注解，需要使用@interface关键字。
例如：public @interface CustomAnnotation {String value();int count() default 1;}上面的例子定义了一个名为CustomAnnotation的注解。
该注解具有两个元素：value和count。
其中，value元素是必需的，而count元素具有默认值为1。
使用注解一旦自定义了注解，就可以将其应用于代码中的各种元素上。
以下是一些使用自定义注解的示例：@CustomAnnotation("Hello")public class MyClass {@CustomAnnotation(value = "World", count = 2)public void myMethod() {// 代码逻辑}}在上面的示例中，我们将自定义注解应用于类和方法上。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
@SuppressWarnings("deprecation")//阻止警告 @HelloAnnotation("当为 value 属性时，可以省掉属性名和等于号。") public static void main(String[] args) throws Exception{ System.runFinalizersOnExit(true); if(AnnotationTest.class.isAnnotationPresent(HelloAnnotation.class)){ HelloAnnotation helloAnnotation = (HelloAnnotation)AnnotationTest.class.getAnnotation(HelloAnnotation.class); System.out.println("color(): "+helloAnnotation.color()); System.out.println("value(): "+helloAnnotation.value()); System.out.println("author(): "+helloAnnotation.author()); System.out.println("arrayAttr(): "+helloAnnotation.arrayAttr().length); System.out.println("annotationAttr(): "+helloAnnotation.annotationAttr().value()); System.out.println("classType(): "+helloAnnotation.classType().newInstance().sayHello("hello,ketty")); } } @Deprecated//自定义：备注过时的方法信息 public static void sayHello(){ System.out.println("hello,world实注解也就是一个类文件 package annotation; import ng.annotation.ElementType; import ng.annotation.Retention; import ng.annotation.RetentionPolicy; import ng.annotation.Target; import entity.PersonChiness; /*** * Retention:保持、保留 * RetentionPolicy：政策、方针 * @author huawei *@Retention *1、指示注释类型的注释要保留多久。如果注释类型声明中不存在 Retention 注释，则保 留策略默认为 RetentionPolicy.CLASS *2、有三种取值(代表三个阶段)： * RetentionPolicy.SOURCE:保留注解到 java 源文件阶段，例如 Override、SuppressWarnings * RetentionPolicy.CLASS:保留注解到 class 文件阶段,例如 * RetentionPolicy.RUNTIME:保留注解到运行时阶段即内存中的字节码,例如 Deprecated */ //元注解：表示的是注解的注解，（同义词有元信息、元数据） //如果不加,javac 会把这无用的注解丢掉 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE,ElementType.METHOD})//指定该注解使用的用处：用在 class 上 和用在方法体上。 public @interface HelloAnnotation {
注解的作用： 1、生成文档。这是最常见的，也是 java 最早提供的注解。常用的有@see @param @return 等 2、跟踪代码依赖性，实现替代配置文件功能。比较常见的是 spring 2.5 开始的基于 注解配置。作用就是减少配置。现在的框架基本都使用了这种配置来减少配置文件的数量。 以后 java 的程序开发，最多的也将实现注解配置，具有很大用处; 3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖 了超类方法，则编译时就能检查出。
下面是实现注解的测试类： package annotation; /*** * 注解类： * 1、相当于一种标记,加上注解就等于为程序打上了某种标记,没加,则等于没加某种标记, * 2、以后 javac 编译器、开发工具或其他应用程序可以通过反射来了解你的类,以及各种元 素上有无何种标记， * 看你有什么标记，就去执行相应的命令和干相应的事。 * 3、标记用处地方： * 加在包、类、字段、方法、方法的参数、局部变量 * @author huawei * */ //自定义注解 @HelloAnnotation(color="红色", value="如果只有 value 属性！可以不写属性名和等于号，直接写值即可！", arrayAttr={1,2,3}, annotationAttr=@MetaAnnotation("返回注解类型规范形式。")) public class AnnotationTest {
//返回值是 String 类型 String color() default "蓝色";//方法，但是相当于注解的属性，即：当成属性赋值，当成方法 调用。 //默认 value String value(); String author() default "默认给定了属性"; //返回值是数组对象 int[] arrayAttr() default {1}; //返回值是注解类型 MetaAnnotation annotationAttr() default @MetaAnnotation(""); //返回 CLASS 对象 Class<PersonChiness> classType() default PersonChiness.class; }