Java的注解

 1 package cn.itcast.annotation.demo1;
 2 
 3 @MyAnno1//注解可以放在类(接口和枚举)上
 4 public class Demo1 {
 5 
 6     @MyAnno1//注解可以放在构造器
 7     public Demo1(){}
 8     @MyAnno1//注解可以放在成员变量上面
 9     private Integer a;
10     @MyAnno1//注解可以放在方法上
11     public void fun1(@MyAnno1 String str){//注解可以放在方法的形参上
12         @MyAnno1//注解可以放在局部变量上
13         int a[];
14         
15 //        @MyAnno1 //不能在执行语句上，不让报错
16         System.out.println("hello");
17     }
18 }
19 
20 /**
21  * 定义注解，所有的注解都是
22  * @author ygh
23  * 2017年1月19日
24  */
25 @interface MyAnno1{
26     
27 }

 1 package cn.itcast.annotation.demo2;
 2 
 3 @MyAnno1(a=100,b="hello")//给注解属性赋值
 4 @MyAnno2(bb="hello")//有默认值的注解属性可以不赋值
 5 @MyAnno3(100)//如果只给注解中名称为value的属性赋值，那么“value=”可以省略
 6 public class Demo2 {
 7 
 8 }
 9 
10 /**
11  * 注解属性的定义
12  * @author ygh
13  * 2017年1月19日
14  */
15 @interface MyAnno1{
16    int a();
17    String b();
18 }
19 
20 @interface MyAnno2{
21     int aa() default 100;//给注解属性默认值
22     String bb();
23 }
24 
25 @interface MyAnno3{
26     int value();
27     String cc() default "ygh";
28 }

 1 /**
 2  * 注解属性的使用
 3  * @author ygh
 4  * 2017年1月19日
 5  */
 6 @MyAnno1(
 7     a=100,
 8     b="hello",
 9     c = Demo1.class,
10     d=@MyAnno2(a=100,b="ygh"),
11     e = MyEnum.A,
12     f={"hello","world"}//如果数组的元素为1,那么{}可以省略，可以写成f="hello"
13 )
14 public class Demo3 {
15 
16 }
17 
18 @interface MyAnno1{
19     int a();
20     String b();
21     Class c();
22     MyAnno2 d();
23     MyEnum e();
24     String[] f();
25 }
26 
27 @interface MyAnno2{
28     int a();
29     String b();
30 }
31 
32 enum MyEnum{
33     A,B,C
34 }

 1 package cn.itcast.annotation.demo4;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 @MyAnno1
 9 public class Demo4 {
10 
11     
12 //    @MyAnno1//报错，因为限定注解只能作用在类和方法上
13     private int a;
14     @MyAnno1
15     public void fun1(){}
16 }
17 
18 @Target(value = { ElementType.TYPE, ElementType.METHOD })
19 @Retention(RetentionPolicy.RUNTIME)//设置注解的保留策略
20 @interface MyAnno1 {
21 }

 1 /*
 2  * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
 3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 4  *
 5  *
 6  *
 7  *
 8  *
 9  *
10  *
11  *
12  *
13  *
14  *
15  *
16  *
17  *
18  *
19  *
20  *
21  *
22  *
23  *
24  */
25 
26 package java.lang.annotation;
27 
28 /**
29  * Indicates the kinds of program element to which an annotation type
30  * is applicable.  If a Target meta-annotation is not present on an
31  * annotation type declaration, the declared type may be used on any
32  * program element.  If such a meta-annotation is present, the compiler
33  * will enforce the specified usage restriction.
34  *
35  * For example, this meta-annotation indicates that the declared type is
36  * itself a meta-annotation type.  It can only be used on annotation type
37  * declarations:
38  * <pre>
39  *    &#064;Target(ElementType.ANNOTATION_TYPE)
40  *    public &#064;interface MetaAnnotationType {
41  *        ...
42  *    }
43  * </pre>
44  * This meta-annotation indicates that the declared type is intended solely
45  * for use as a member type in complex annotation type declarations.  It
46  * cannot be used to annotate anything directly:
47  * <pre>
48  *    &#064;Target({})
49  *    public &#064;interface MemberType {
50  *        ...
51  *    }
52  * </pre>
53  * It is a compile-time error for a single ElementType constant to
54  * appear more than once in a Target annotation.  For example, the
55  * following meta-annotation is illegal:
56  * <pre>
57  *    &#064;Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD})
58  *    public &#064;interface Bogus {
59  *        ...
60  *    }
61  * </pre>
62  */
63 @Documented
64 @Retention(RetentionPolicy.RUNTIME)
65 @Target(ElementType.ANNOTATION_TYPE)
66 public @interface Target {
67     ElementType[] value();
68 }

 1 /*
 2  * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
 3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 4  *
 5  *
 6  *
 7  *
 8  *
 9  *
10  *
11  *
12  *
13  *
14  *
15  *
16  *
17  *
18  *
19  *
20  *
21  *
22  *
23  *
24  */
25 
26 package java.lang.annotation;
27 
28 /**
29  * A program element type.  The constants of this enumerated type
30  * provide a simple classification of the declared elements in a
31  * Java program.
32  *
33  * <p>These constants are used with the {@link Target} meta-annotation type
34  * to specify where it is legal to use an annotation type.
35  *
36  * @author  Joshua Bloch
37  * @since 1.5
38  */
39 public enum ElementType {
40     /** Class, interface (including annotation type), or enum declaration */
41     TYPE,
42 
43     /** Field declaration (includes enum constants) */
44     FIELD,
45 
46     /** Method declaration */
47     METHOD,
48 
49     /** Parameter declaration */
50     PARAMETER,
51 
52     /** Constructor declaration */
53     CONSTRUCTOR,
54 
55     /** Local variable declaration */
56     LOCAL_VARIABLE,
57 
58     /** Annotation type declaration */
59     ANNOTATION_TYPE,
60 
61     /** Package declaration */
62     PACKAGE
63 }

 1 /*
 2  * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
 3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 4  *
 5  *
 6  *
 7  *
 8  *
 9  *
10  *
11  *
12  *
13  *
14  *
15  *
16  *
17  *
18  *
19  *
20  *
21  *
22  *
23  *
24  */
25 
26 package java.lang.annotation;
27 
28 /**
29  * Indicates how long annotations with the annotated type are to
30  * be retained.  If no Retention annotation is present on
31  * an annotation type declaration, the retention policy defaults to
32  * {@code RetentionPolicy.CLASS}.
33  *
34  * <p>A Retention meta-annotation has effect only if the
35  * meta-annotated type is used directly for annotation.  It has no
36  * effect if the meta-annotated type is used as a member type in
37  * another annotation type.
38  *
39  * @author  Joshua Bloch
40  * @since 1.5
41  */
42 @Documented
43 @Retention(RetentionPolicy.RUNTIME)
44 @Target(ElementType.ANNOTATION_TYPE)
45 public @interface Retention {
46     RetentionPolicy value();
47 }

/*
 * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang.annotation;

/**
 * Annotation retention policy.  The constants of this enumerated type
 * describe the various policies for retaining annotations.  They are used
 * in conjunction with the {@link Retention} meta-annotation type to specify
 * how long annotations are to be retained.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}