Java annotation examples

Reprinted from: http://www.iteye.com/topic/400085

 

Annotation provides a formal method for us to use the information in the Code Zhongtian domain.

You can easily use the data at a specific time (using the data through parsing annotations ).

 

The annotation syntax is relatively simple. Besides the use of the @ symbol, it is basically consistent with the inherent Syntax of Java. Java has three built-in

Annotation, which is defined in the Java. lang package.

@ OverrideIndicates that the current method overwrites the parent class.

@ DeprecatedIt indicates that the current element is not in favor of use.

@ SuppresswarningsIndicates disabling some improper compiler warning information.

 

The following is an example of defining Annotations:

 

Java code

1. Package test_annotation;
3. Import java. Lang. annotation. incluented;
4. Import java. Lang. annotation. inherited;
5. Import java. Lang. annotation. retention;
6. Import java. Lang. annotation. target;
7. Import java. Lang. annotation. elementtype;
8. Import java. Lang. annotation. retentionpolicy;
10. /*
11. * Meta annotation @ target, @ retention, @ incluented, @ inherited
     
12. *
13. * @ Target indicates where the annotation is used. Possible elemenettype parameters include:
     
14. * Elemenettype. constructor Declaration
     
15. * Elemenettype. Field field Declaration (including Enum instances)
     
16. * Elemenettype. local_variable local variable Declaration
     
17. * Elemenettype. Method method declaration
18. * Elemenettype. Package package Declaration
19. * Elemenettype. Parameter parameter Declaration
20. * Elemenettype. Type class, interface (including annotation type) or enum Declaration
     
21. *
22. * @ Retention indicates the level at which the annotation information is saved. Optional retentionpolicy parameters include:
     
23. * The retentionpolicy. Source annotation will be discarded by the compiler.
     
24. * The retentionpolicy. Class annotation is available in the class file, but is discarded by the VM.
     
25. * Retentionpolicy. runtime VM also retains annotations during runtime. Therefore, the annotation information can be read through the reflection mechanism.
     
26. *
27. * @ Brief ented include this annotation in javadoc
28. *
29. * @ Inherited allows subclass to inherit the annotation in the parent class
30. *
31. */
32. @ Target (elementtype. Method)
33. @ Retention (retentionpolicy. runtime)
34. @ Brief ented
35. @ Inherited
36. /*
37. * Define annotation Test
38. * The annotation contains two elements: ID and description.
39. * The default value of the description element is "no description"
40. */
41. Public @ Interface Test {
42. Public int ID ();
43. Public String description () Default "no description ";
44. }

Package test_annotation; import Java. lang. annotation. documented; import Java. lang. annotation. inherited; import Java. lang. annotation. retention; import Java. lang. annotation. target; import Java. lang. annotation. elementtype; import Java. lang. annotation. retentionpolicy;/** meta annotation @ target, @ retention, @ incluented, @ inherited ** @ target indicates where the annotation is used. Possible elemenettype parameters include: * elemenettype. constructor Declaration * elemenettyp E. field field Declaration (including Enum instances) * elemenettype. local_variable local variable Declaration * elemenettype. method method declaration * elemenettype. package package Declaration * elemenettype. parameter parameter Declaration * elemenettype. type class, interface (including annotation type) or enum declaration ** @ retention indicates the level at which the annotation information is saved. Optional retentionpolicy parameters include: * retentionpolicy. the source annotation will be discarded by the compiler * retentionpolicy. the class annotation is available in the class file, but it will be discarded by the VM * retentionpolicy. the runtime VM also keeps comments at runtime, so the annotation information can be read through the reflection mechanism. ** @ Brief ented include this annotation in javadoc ** @ inherited allows the subclass to inherit the annotation in the parent class **/@ target (elementtype. method) @ retention (retentionpolicy. runtime) @ brief ented @ inherited/** definition annotation test * contains two elements: ID and Description * description. The default value is "no description" */Public @ Interface Test {public int ID (); public String description () Default "no description ";}

The following is an example of using annotation and parsing annotation.

 

Java code

1. Package test_annotation;
3. Import java. Lang. Reflect. method;
5. Public class test_1 {
6. /*
7. * Three annotated Methods
8. */
9. @ Test (ID = 1, description = "Hello method_1 ")
10. Public void method_1 (){
11. }
13. @ Test (ID = 2)
14. Public void method_2 (){
15. }
17. @ Test (ID = 3, description = "last method ")
18. Public void method_3 (){
19. }
21. /*
22. * Parse the annotation and print the information of all annotation methods of test_1.
23. */
24. Public static void main (string [] ARGs ){
25. Method [] Methods = test_1.class.getdeclaredmethods ();
26. For (method: Methods ){
27. /*
28. * Determine whether there are annotations of the specified annotation type in the Method
29. */
30. Boolean hasannotation = method. isannotationpresent (test. Class );
31. If (hasannotation ){
32. /*
33. * Return the specified type annotation of a method based on the annotation type
34. */
35. Test annotation = method. getannotation (test. Class );
36. System. Out. println ("test (method =" + method. getname ()
37. + ", Id =" + annotation. ID () + ", description ="
38. + Annotation. Description () + ")");
39. }
40. }
41. }
43. }

Package test_annotation; import Java. lang. reflect. method; public class test_1 {/** three methods annotated */@ test (ID = 1, description = "Hello method_1") Public void method_1 () {}@ test (ID = 2) Public void method_2 () {}@ test (ID = 3, description = "last method") Public void method_3 () {}/** parse the annotation and print the information of all annotation methods of test_1 class */public static void main (string [] ARGs) {method [] Methods = test_1.class.getdeclaredmethods (); For (method: Methods) {/** determines whether there are annotations for the specified annotation type in the Method */Boolean hasannotation = method. isannotationpresent (test. class); If (hasannotation) {/** specify the type annotation of the method returned Based on the annotation type */test annotation = method. getannotation (test. class); system. out. println ("test (method =" + method. getname () + ", id =" + annotation. ID () + ", description =" + annotation. description () + ")");}}}}

The output result is as follows: Test (method = method_1, id = 1, description = Hello method_1) test (method = method_2, id = 2, description = no description) test (method = method_3, id = 3, description = last method)