Core Java Volume II—Using annotations

Posted hu-yan

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Core Java Volume II—Using annotations相关的知识,希望对你有一定的参考价值。

Annotations are tags that you insert into your source code so that some tool can process them. The tools can operate on source level or they can process class files into which the compiler has placed annotations.

Uses for annotations:

  • Automatic generation of auxiliary files such as deployment descriptors or bean information classes
  • Automatic generation of code for testing, logging, transaction semantics, and so on

Junit 4 testing tool calls all methods that are labeled @test when testing a class.

Annotations can be defined to have elements which can be processed by the tools that read the annotations.

An annotation can be put anywhere that you could put a modifier.

You can annotate packages, parameter variables, type parameters, and type uses.

Each annotation must be defined by an annotation interface. The methods of the interface correspond to the elements of the annotation.

The @interface declaration creates an actual Java interface.

Annotation Syntax:

An annotation is defined by a annotation interface:

modifiers @interface AnnotationName{
    elementDeclaration1;
    elementDeclaration2;
    …
}

 

Each element declaration has the form

type elementName();

or

type elementName() default value;

You cannot extend annotation interfaces.

The type of an annotation element is one of the following:

  • A primitive type
  • String
  • Class
  • An enum type
  • An annotation type
  • An array of the preceding types(an array of arrays is not a legal element type)

Each element has the format

@AnnotationName(elementName1 = value1, elementName2 = value2, …) // the order of elements does not matter.

The default value of the declaration is used if an element value is not specified.

If no elements are specified, you don‘t need to use parentheses.

@AnnotationName

The single value annotation

If an element has the special name value and no other element is specified, you can omit the element name and the = symbol.

An item can have multiple annotations, if an annotation is repeatable, you can repeat same annotation multiple times.

An annotation element can never be set to null. You can find other defaults such as "" or Void.class.

2 main use of annotation: declarations and type uses.

Declaration annotations can appear at the declaration of:

  • Packages
  • Classes
  • Interfaces
  • Methods
  • Constructors
  • Instances fields (including enum constants)
  • Local variables
  • Parameter variables
  • Type parameters

For classes and interfaces, put the annotations before the class or interface keyword; for variables, put them before the type; for type parameters <@AnnotationName V>; for packages, the package-info.java contains only the package statement preceded by annotations.

Type use annotations can appear in the following places:

  • With generic type arguments
  • In any position of an array
  • With superclasses and implemented interfaces:
  • With constructor invocations
  • With instanceof checks and casts
  • With exception specifications
  • With method and constructor references: eg. @Annotation Message::getText

Custom:

  • Put type use annotations after other modifiers;
  • Put declaration annotations before other modifiers.

An annotation placed on the constructor describes a property of the constructed object.

Annotation

Purpose

@Generated

Code generator tools

@PostConstruct

 

@PreDestroy

In environments that control the life-circle of objects—methods tagged with these annotations should be invoked immediately after an object has been constructed or before is being removed.

@Resource

Resource injection

@Target({ElementType.X, ElementType.Y, …})

Apply to an annotation, retricting the items to which the annotation applies.

@Rentention

Specifies how long an annotation is retained (SOURCE, CLASS, RUNTIME).

@Documented

The documentation of each annotated method/… contains the annotation.

@Inherited

Only applies to classes, all of the subclasses automatically have the same annotation.

Java SE 8 -> Legal to apply the same annotation type multiple times to an item. For backward compatibility, the implementor of a repeatable annotation needs to provide a container annotation that holds the repeated annotations in an array.

Whenever the user supplies 2 or more @TestCase annotations, they are automatically wrapped into a @TestCases annotation.

以上是关于Core Java Volume II—Using annotations的主要内容,如果未能解决你的问题,请参考以下文章

Attach Volume 操作(Part II) - 每天5分钟玩转 OpenStack(54)

O054Attach Volume 操作(Part II)

Create Volume 操作(Part II) - 每天5分钟玩转 OpenStack(51)

Create Volume 操作(Part II) - 每天5分钟玩转 OpenStack(51)

Attach Volume 操作(Part II) - 每天5分钟玩转 OpenStack(54)

《PWC-Net:CNNs for Optical Flow Using Pyramid,Warping,and Cost Volume》论文笔记