Annotation(注解)

Jackson常⽤注解annotation（转）1、⾃动检测，（作⽤在类上）来开启/禁⽌⾃动检测。

fieldVisibility:字段的可见级别ANY:任何级别的字段都可以⾃动识别NONE:所有字段都不可以⾃动识别NON_PRIVATE:⾮private修饰的字段可以⾃动识别PROTECTED_AND_PUBLIC:被protected和public修饰的字段可以被⾃动识别PUBLIC_ONLY:只有被public修饰的字段才可以被⾃动识别DEFAULT:jackson默认的字段属性发现规则如下：所有被public修饰的字段->所有被public修饰的getter->所有被public修饰的setter）2、作⽤在字段或⽅法上，⽤来完全忽略被注解的字段和⽅法对应的属性.3、作⽤在字段或⽅法上，⽤来对属性的序列化/反序列化，可以⽤来避免遗漏属性，同时提供对属性名称重命名4、作⽤在类上，⽤来说明有些属性在序列化/反序列化时需要忽略掉，可以将它看做是@JsonIgnore的批量操作，但它的功能⽐@JsonIgnore要强，⽐如⼀个类是代理类，我们⽆法将将@JsonIgnore标记在属性或⽅法上，此时便可⽤@JsonIgnoreProperties标注在类声明上，它还有⼀个重要的功能是作⽤在反序列化时解析字段时过滤⼀些未知的属性，否则通常情况下解析到我们定义的类不认识的属性便会抛出异常。

可以注明是想要忽略的属性列表如@JsonIgnoreProperties({"name","age","title"})，也可以注明过滤掉未知的属性如@JsonIgnoreProperties(ignoreUnknown=true)5、作⽤在属性字段或⽅法上，⽤来将⼦JSON对象的属性添加到封闭的JSON对象。

6、2.0+版本新注解，作⽤于类或属性上，被⽤来在序列化/反序列化时为该对象或字段添加⼀个对象识别码，通常是⽤来解决循环嵌套的问题7、jackson 2.1+版本的注解，作⽤于类或⽅法，注意这个注解是在jackson-databind包中⽽不是在jackson-annotations包⾥，它可以让你定制属性命名策略，作⽤和前⾯提到的@JsonProperty的重命名属性名称相同。

java 利用注解为类添加方法Java 利用注解为类添加方法引言在Java中，我们可以使用注解来为类添加方法。

注解是一种元数据，它可以在编译时或运行时提供特定的信息。

通过使用注解，我们可以在不修改源代码的情况下，为类添加额外的方法。

基本概念在开始学习如何使用注解为类添加方法之前，我们首先要了解几个基本的概念：1.注解（Annotation）：注解是一种特殊的接口，用于为代码提供元数据。

注解以@符号开始，紧接着是注解的名称。

例如：@MyAnnotation。

2.元数据（Metadata）：元数据是描述数据的数据。

在这里，注解就是元数据，它可以为我们的代码提供额外的信息。

3.注解处理器（Annotation Processor）：注解处理器是一个用于处理注解的工具，它可以通过在编译时或运行时扫描代码，并根据注解提供的信息生成额外的代码。

现在，让我们来看看如何使用注解为类添加方法。

使用注解为类添加方法的方法1. 定义一个注解首先，我们需要定义一个注解，用于为类添加方法。

我们可以使用@interface关键字来定义一个注解，接着在注解内部定义我们需要的方法。

public @interface AddMethod {String value();}在上面的例子中，我们定义了一个名为AddMethod的注解，并在注解内部定义了一个名为value的方法。

这个方法用于指定要添加的方法的名称。

2. 创建一个注解处理器接下来，我们需要创建一个注解处理器来处理我们之前定义的注解。

注解处理器是一个实现了Processor接口的类，它可以通过注解提供的信息生成额外的代码。

public class AddMethodProcessor implements Processo r {@Overridepublic void process(Set<? extends TypeElement> annotat ions, RoundEnvironment roundEnv) {// 在这里处理注解，并生成额外的代码}@Overridepublic Set<String> getSupportedAnnotationTypes() {return (());}@Overridepublic SourceVersion getSupportedSourceVersion() {return ();}}在上面的例子中，我们创建了一个名为AddMethodProcessor的注解处理器，并实现了Processor接口的相关方法。

think-annotation 模型注解链式操作
Think-Annotation是一个用于ThinkPHP框架的注解库，提供注解的方式来简化路由、模型等代码的编写。

关于模型的注解，你可以在模型类上直接使用注解来定义模型的属性、方法和关系，而不需要在模型类中编写大量的代码。

这有助于减少代码量，提高开发效率。

至于链式操作，这是面向对象编程中常见的一种编程风格，允许你在一条语句中连续调用多个方法。

例如，在Think-Annotation模型注解中，你可以通过链式调用来完成多个操作，比如：
php复制代码：
@chain('email', 'active', 'sms')
这样的代码可以在一行内定义多个注解。

具体链式操作的语法和使用方式可能因具体的编程语言和框架而有所不同，因此建议查阅Think-Annotation的官方文档或相关教程以获取更详细的信息。

动态修改注解（annotation）值项⽬中⽤到了 @JsonIgnore 注解，因为类中有个详细信息，这个详细信息在返给前端列表时⽤不到，只在查看详情时才会⽤到。

所以详情字段加上了@JsonIgnore，它的默认值是true.所以在查看详情时，还要给前端返回这个详情字段。

就要动态将@JsonIgnore设置成false。

这个是通过反射完成的。

因为查看详情通常情况下，只返回⼀个pojo，所以在这⾥⽤反射，不会影响系统的性能。

假设⼀个类, Detailpublic class Detail implements Serializable {...@JsonIgnoreprivate String detail;...}现在要将@JsonIgnore的值改为falsepublic Detail getDetail(String id) {Detail detail = repository.findOne(id);try {Field detailField = message.getClass().getDeclaredField("detail");if (detailField != null) {detailField.setAccessible(true);JsonIgnore annotation = detailField.getAnnotation(JsonIgnore.class);if (annotation != null) {InvocationHandler ih = Proxy.getInvocationHandler(annotation);Field memberValuesField = ih.getClass().getDeclaredField("memberValues");memberValuesField.setAccessible(true);Map memberValues = (Map)memberValuesField.get(ih);memberValues.put("value", false); // set value to false}}}catch(Exception e) {e.printStackTrace();}return Detail;}还有这个：<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.33</version></dependency>参考⽂章： https:///a/11900000112132222018/6/3: 补充⼀下因为所有对象共有⼀个class对象，所以在将详情字段设为可见后，再查看列表，详情也是可见的。

idea中enable annotation-概述说明以及解释1.引言1.1 概述在现代软件开发中，annotation（注解）已经成为一种非常重要的编程工具。

它能够在不改变程序代码逻辑的情况下，为程序提供额外的元数据信息，从而帮助程序员更好地组织和管理代码。

在以Java为代表的编程语言中，annotation被广泛应用于各种场景，包括配置管理、文档生成、代码分析等。

在集成开发环境（IDE）中，如IntelliJ IDEA（以下简称IDEA），启用annotation功能可以大大提高开发效率和代码质量。

通过annotation，开发者可以更直观地了解代码结构和意图，减少代码重复和错误，同时提高代码的可读性和维护性。

因此，了解如何在IDEA中启用annotation 是每个开发者必备的技能之一。

本文将介绍在IDEA中启用annotation的方法，以及启用annotation 的重要性和实际应用场景。

希望通过本文的介绍，读者能够更好地理解并掌握在IDEA中使用annotation的技巧和方法，从而在软件开发中获得更好的效果和体验。

1.2 文章结构：本文主要由引言、正文和结论三个部分组成。

在引言部分，将对idea中的annotation进行概述，介绍文章的结构和目的。

在正文部分，将阐述什么是idea中的annotation，为什么需要在idea 中启用annotation，以及如何在idea中启用annotation。

在结论部分，将对整篇文章进行总结，提出应用建议，并展望未来对于annotation在idea中的发展。

1.3 目的在本文中，我们的主要目的是探讨在IntelliJ IDEA（以下简称idea）中启用annotation 的必要性和方法。

通过了解什么是annotation、为什么要在idea 中启用annotation，以及如何实现这一操作，我们可以更好地利用idea 提供的丰富功能和工具，提高代码的可读性、可维护性和可扩展性。

XML注释与Description标签及Java：注解（Annotation）的关系⼀.摘要.Net允许开发⼈员在源代码中插⼊XML注释，这在多⼈协作开发的时候显得特别有⽤。

C#解析器可以把代码⽂件中的这些XML标记提取出来，并作进⼀步的处理为外部⽂档。

这篇⽂章将展⽰如何使⽤这些XML注释。

在项⽬开发中，很多⼈并不乐意写繁杂的⽂档。

但是，开发组长希望代码注释尽可能详细；项⽬规划⼈员希望代码设计⽂档尽可能详尽；测试、检查⼈员希望功能说明书尽可能详细等等。

如果这些⽂档都被要求写的话，保持它们同步⽐进⾏⼀个战役还痛苦。

为何不把这些信息保存在⼀个地⽅呢？？最明显想到的地⽅就是代码的注释中；但是你很难通览程序，并且有些需要这些⽂档的⼈并不懂编码。

最好的办法是通过使⽤XML注释来解决这些问题。

代码注释、⽤户⼿册、开发⼈员⼿册、测试计划等很多⽂档可以很⽅便的从XML注释中获得。

本⽂讲解.Net中经常使⽤的XML注释.主要使⽤C#语⾔j,.Net平台⽀持的其他语⾔使⽤的XML注释格式基本相同.并且在本系列⽂章的下⼀讲中讲解如何使⽤⼯具将XML注释内容转化为帮助⽂档.⼆.XML注释概述所有的XML注释都在三个向前的斜线之后(///)。

两条斜线表⽰是⼀个注释，编译器将忽略后⾯的内容。

三条斜线告诉编译器，后⾯是XML注释，需要适当地处理。

当开发⼈员输⼊三个向前的斜线后，Microsoft Visual Studio .NET IDE ⾃动检查它是否在类或者类成员的定义的前⾯。

如果是的话，Visual Studio .NET IDE 将⾃动插⼊注释标记，开发⼈员只需要增加些额外的标记和值。

下⾯就是在成员函数前增加三个斜线，⾃动增加的注释⽐如:/// <summary>/// 得到指定酒店的酒店信息/// </summary>/// <param name="hotelId">酒店Id</param>/// <param name="languageCode">语⾔码.中⽂为zh-cn</param>/// <returns>酒店信息对象</returns>[OperationContract]OutHotelInfo GetHotelInfoByHotelId(string loginName, string loginPassword, string hotelId, string languageCode);这⾥嵌⼊的summary,param,returns标记仅仅是Visual Studio能够识别的⼀部分标记，然⽽在智能感知IntelliSense中，并没有把c#规范中所有的标记列出来，遗失的部分只能⽤⼿⼯插⼊。

元数据的作用如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类：l 编写文档：通过代码里标识的元数据生成文档。

l 代码分析：通过代码里标识的元数据对代码进行分析。

l 编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。

基本内置注释@Override注释能实现编译时检查，你可以为你的方法添加该注释，以声明该方法是用于覆盖父类中的方法。

如果该方法不是覆盖父类的方法，将会在编译时报错。

例如我们为某类重写toString()方法却写成了tostring()，并且我们为该方法添加了@Override注释；@Deprecated的作用是对不应该在使用的方法添加注释，当编程人员使用这些方法时，将会在编译时显示提示信息，它与javadoc里的@deprecated标记有相同的功能，准确的说，它还不如javadoc @deprecated，因为它不支持参数，注意：要了解详细信息，请使用-Xlint:deprecation 重新编译。

@SuppressWarnings与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数值都是已经定义好了的，我们选择性的使用就好了，参数如下：deprecation 使用了过时的类或方法时的警告unchecked 执行了未检查的转换时的警告，例如当使用集合时没有用泛型(Generics) 来指定集合保存的类型fallthrough 当Switch 程序块直接通往下一种情况而没有Break 时的警告path 在类路径、源文件路径等中有不存在的路径时的警告serial 当在可序列化的类上缺少serialVersionUID 定义时的警告finally 任何finally 子句不能正常完成时的警告all 关于以上所有情况的警告注意：要了解详细信息，请使用-Xlint:unchecked 重新编译。

定制注释类型好的，让我们创建一个自己的注释类型（annotation type）吧。

注解获取某个参数的方法在许多编程语言中，包括Java、Python、C++ 等，你可以通过注解（Annotation）或装饰器（Decorator）来获取某个参数的信息。

以下是一些常见语言的示例：1. Java 中获取方法参数的注解：在Java 中，你可以使用反射机制结合注解来获取方法的参数信息。

假设有以下注解定义：```javaimport ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.PARAMETER)public @interface MyParamAnnotation {String value();}```然后，你可以在方法参数上使用这个注解：```javapublic class MyClass {public void myMethod(@MyParamAnnotation("parameterName") String param) { // 方法体}}```接下来，通过反射获取方法参数上的注解：```javaimport ng.annotation.Annotation;import ng.reflect.Method;import ng.reflect.Parameter;public class Main {public static void main(String[] args) throws NoSuchMethodException {Method method = MyClass.class.getMethod("myMethod", String.class);Parameter[] parameters = method.getParameters();for (Parameter parameter : parameters) {Annotation[] annotations = parameter.getAnnotations();for (Annotation annotation : annotations) {if (annotation instanceof MyParamAnnotation) {MyParamAnnotation myAnnotation = (MyParamAnnotation) annotation;System.out.println("Parameter: " + parameter.getName() +", Annotation value: " + myAnnotation.value());}}}}}```2. Python 中获取函数参数的装饰器：在Python 中，你可以使用装饰器来获取函数参数的信息。

关于Spring中的context：annotation-config配置（开启注解）当我们需要使⽤BeanPostProcessor时，直接在Spring配置⽂件中定义这些Bean显得⽐较笨拙，例如： 使⽤@Autowired注解，必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessor的Bean：<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor "/> 使⽤ @Required注解，就必须声明RequiredAnnotationBeanPostProcessor的Bean：<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor"/> 类似地，使⽤@Resource、@PostConstruct、@PreDestroy等注解就必须声明 CommonAnnotationBeanPostProcessor；使⽤@PersistenceContext注解，就必须声明 PersistenceAnnotationBeanPostProcessor的Bean。

这样的声明未免太不优雅，⽽Spring为我们提供了⼀种极为⽅便注册这些BeanPostProcessor的⽅式，即使⽤<context:annotation-config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。

环境：Hibernate 3.3.1Maven 3.0.4MySQL 5.5.13Myeclipse 8.6.1建表语句：DROP TABLE IF EXISTS `t_card`;CREATE TABLE `t_card` (`cardId` int(10) unsigned NOT NULL AUTO_INCREMENT,`cardNumber` char(18) NOT NULL,PRIMARY KEY (`cardId`)) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_card` VALUES ('1', '440911************');DROP TABLE IF EXISTS `t_person`;CREATE TABLE `t_person` (`personId` int(10) unsigned NOT NULL AUTO_INCREMENT,`personName` varchar(15) NOT NULL,`cid` int(10) unsigned NOT NULL,PRIMARY KEY (`personId`)) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_person` VALUES ('1', 'fancy', '1');Person.javapackage com.fancy.po;import javax.persistence.CascadeType;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.OneToOne;import javax.persistence.Table;/*** -----------------------------------------* @文件: Person.java* @作者: fancy* @邮箱: fancyzero@* @时间: 2012-6-10* @描述: 实体类* -----------------------------------------*//*** @Entity 声明一个类为实体Bean* @Table(name = "xx")指定实体类映射的表,如果表名和实体类名一致,可以不指定*/@Entity@Table(name = "t_person")public class Person {private Integer personId;private String personName;private Card card;/*** @Id 映射主键属性,这里采用uuid的主键生成策略* @GeneratedValue ——注解声明了主键的生成策略。

在PHP 中，注解（Annotation）是一种元数据标记，用于提供有关代码的附加信息。

注解通常用于框架、库或应用程序中，以便在运行时或编译时解析和处理这些信息。

要在PHP 中使用注解，您需要使用一个支持注解的框架或库。

一些流行的框架和库包括Symfony、Doctrine、Annotation 和Annotate PHP 等。

下面是一个示例，展示了如何在PHP 中使用注解标记一个方法：
php
/**
* @annotation
*/
class MyAnnotation
{
/**
* @method
*/
public function myMethod()
{
// 方法实现
}
}
在上面的示例中，我们定义了一个名为MyAnnotation的类，并在其中定义了一个名为myMethod的方法。

我们使用@method注解标记该方法，表示它是一个注解方法。

要使用该注解方法，您需要创建一个MyAnnotation实例，并调用该方法。

具体如何使用取决于您使用的框架或库的约定。

以下是一个简单的示例：
php
use MyAnnotation;
$annotation = new MyAnnotation();
$annotation->myMethod(); // 调用注解方法。

authorityannotation 注解`AuthorityAnnotation`注解并非Java标准注解，但根据您的描述，我猜您是想了解如何在Java代码中处理权限相关的注解。

在Java中，我们可以使用自定义注解来表示权限信息，以下是一个简单的例子：1. 首先，创建一个表示权限的枚举类型：```javapublic enum Authority {ADMIN("管理员"),USER("普通用户");private String description;Authority(String description) {this.description = description;}public String getDescription() {return description;}}```2. 接下来，创建一个表示权限信息的注解：```javaimport ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface Authorized {Authority value() default ER;}```3. 在需要处理权限的地方使用`@Authorized`注解：```javapublic class UserService {@Authorized(Authority.ADMIN)public void adminAction() {System.out.println("管理员权限执行的操作");}@Authorized(ER)public void userAction() {System.out.println("普通用户权限执行的操作");}}```4. 最后，在运行时通过反射获取方法的权限信息并进行检查：```javaimport ng.reflect.Method;public class Main {public static void main(String[] args) {try {UserService userService = new UserService();Class<?>[] classes =userService.getClass().getDeclaredClasses();for (Class<?> clazz : classes) {Method[] methods = clazz.getDeclaredMethods();for (Method method : methods) {Authorized authorized = method.getAnnotation(Authorized.class);if (authorized != null) {Authority authority = authorized.value();System.out.println("方法名：" + method.getName() + "，权限：" + authority.getDescription());}}}} catch (Exception e) {e.printStackTrace();}}}```这个例子中，我们使用自定义的`Authority`枚举和`Authorized`注解来表示权限信息。

PHP 7和PHP 8中的注解（Annotations）都是用于在代码中添加元数据的一种方式。

这些元数据可以用于配置、文档化、增强代码的功能和行为。

在PHP 7中，注解是通过使用特殊的注释语法来实现的。

以下是一个示例：```php/*** @annotation*/public function myFunction() {// 函数体}```在上面的示例中，`@annotation`是注解的标签。

注解标签可以根据需要自定义，可以根据项目的需求和约定进行定义。

在PHP 8中，注解的语法没有发生太大变化。

以下是一个与上述示例类似的示例：```php/*** @annotation*/public function myFunction() {// 函数体}```PHP 8中的注解语法与PHP 7基本相同，但PHP 8引入了一些新的注解特性。

例如，PHP 8支持在类属性上使用注解，这使得在类属性上添加元数据变得更加方便。

以下是一个示例：```php/*** @annotation*/public $myProperty;```此外，PHP 8还提供了一些新的注解标签和功能，例如对注解标签进行参数化，以及对注解标签进行过滤和分组等。

这些新特性可以用于更精细地控制代码的行为和功能。

需要注意的是，注解只是代码中的元数据，它们本身并不会影响代码的执行逻辑。

它们通常用于在运行时或编译时生成额外的代码或配置文件，或者用于文档生成和代码生成工具等。

具体的注解处理方式取决于使用注解的框架或库的实现方式。

注解与反射机制（Annocation、Reflection）注解（Java.Annotation）注释（comment）注解作⽤：1.可以被其他程序（⽐如：编译器等）读取2.不是程序本⾝，可以对程序作出解释（和注释差不多）注解的格式：@注解名，还可以添加⼀些内置参数值⽐如@SuppressWarnings(value = "unchecked")注解的使⽤地点：可以在package，class，method，field上使⽤，相当于给他们添加了⼀些辅助信息，我们可以通过反射机制编程实现对这些源数据的访问内置注解注解的常⽤⼏种：@Override ⽅法的重写@Deprecated 不推荐使⽤，或存在危险，有更好的⽅法替代，但是可以使⽤，使⽤的⽅法打有横杠@SuppressWarnings()镇压警告，编写代码时，黄⾊警告被镇压，后⾯有参数，可以传递⼀个或多个参数@SuppressWarnings("all")@SuppressWarnings("unchecked")@SuppressWarnings("unchecked","desprecatoin"),元注解作⽤：⽤来注解其他注解//Target，⽤来注解⾃定义注解的使⽤范围，//参数类型 ElementType[] value()@Target(value = {ElementType.METHOD,ElementType.TYPE})//Retention,表⽰注解在什么时候有效//SOURCE<CLASS<RUNTIME@Retention(RetentionPolicy.SOURCE)//Documented 该注解是否出现在javadoc⾥⾯@Documented//Inherited ⼦类可以继承⽗类的注解@Inherited@interface MyAnnotation{}⾃定义注解package annotation;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;//⾃定义注解public class TestAnnotation02 {//注解可以显⽰赋值，如果没有默认值，必须赋值@MyAnnotation02(name = "⼩明")public void test01(){}@MyAnnotation03("⼩明")public void test03(){}}//元注解，对⾃定义注解的注解@Target({ElementType.TYPE,ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)//⾃定义注解的格式 public @interface ⾃定义注解名@interface MyAnnotation02{// 注解的参数参数类型参数名() ；String name();//设置默认值格式为参数类型参数名() default 默认值；int age() default 21;}@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@interface MyAnnotation03{//如果注释中只有⼀个参数，将参数名命名为value，这样在赋值时候，可以省略赋值名String value();}添加的这些辅助信息，可以通过反射机制来读取这些元数据信息反射机制（Reflection）静态语⾔与动态语⾔动态语⾔：在运⾏的时候可以改变其结构的语⾔：⽐如javascript、Object-C、C#、PHP、phython静态语⾔：在运⾏时结构不发⽣改变：⽐如Java，C，C++Java不是动态语⾔，但是可以通过反射机制来获得类似动态语⾔，可以成为“准动态语⾔”。

以通过default来声明参数的默认值。

定义注解格式：public @interface 注解名{定义体}注解参数的可支持数据类型：1.所有基本数据类型（int,float,boolean,byte,double,char,long,short)2.String类型3.Class类型4.enum类型5.Annotation类型6.以上所有类型的数组Annotation类型里面的参数该怎么设定:第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。

简单的自定义注解和使用注解实例：package annotation;import ng.annotation.Documented;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;/*** 水果名称注解* @author peida**/@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface FruitName {String value() default "";}package annotation;import ng.annotation.Documented; import ng.annotation.ElementType; import ng.annotation.Retention; import ng.annotation.RetentionPolicy; import ng.annotation.Target;/*** 水果颜色注解* @author peida**/@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface FruitColor {/*** 颜色枚举* @author peida**/public enum Color{ BULE,RED,GREEN};/*** 颜色属性* @return*/Color fruitColor() default Color.GREEN;}package annotation;import annotation.FruitColor.Color;public class Apple {@FruitName("Apple")private String appleName;@FruitColor(fruitColor=Color.RED)private String appleColor;public void setAppleColor(String appleColor) {this.appleColor = appleColor;}public String getAppleColor() {return appleColor;}public void setAppleName(String appleName) {this.appleName = appleName;}public String getAppleName() {return appleName;}public void displayName(){System.out.println("水果的名字是：苹果");}}注解元素的默认值：注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。